packages feed

gi-gtk 0.3.18.10 → 0.3.18.12

raw patch · 657 files changed

+212820/−27564 lines, 657 filesdep ~gi-atkdep ~gi-cairodep ~gi-gdk

Dependency ranges changed: gi-atk, gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, haskell-gi-base

This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.

Files

GI/Gtk.hs view

file too large to diff

+ GI/Gtk/Callbacks.hs view
@@ -0,0 +1,2884 @@++{- |+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.Gtk.Callbacks+    ( ++ -- * Signals+-- ** AccelGroupActivate+    AccelGroupActivate                      ,+    AccelGroupActivateC                     ,+    accelGroupActivateClosure               ,+    accelGroupActivateWrapper               ,+    mkAccelGroupActivate                    ,+    noAccelGroupActivate                    ,+++-- ** AccelGroupFindFunc+    AccelGroupFindFunc                      ,+    AccelGroupFindFuncC                     ,+    accelGroupFindFuncClosure               ,+    accelGroupFindFuncWrapper               ,+    mkAccelGroupFindFunc                    ,+    noAccelGroupFindFunc                    ,+++-- ** AccelMapForeach+    AccelMapForeach                         ,+    AccelMapForeachC                        ,+    accelMapForeachClosure                  ,+    accelMapForeachWrapper                  ,+    mkAccelMapForeach                       ,+    noAccelMapForeach                       ,+++-- ** AssistantPageFunc+    AssistantPageFunc                       ,+    AssistantPageFuncC                      ,+    assistantPageFuncClosure                ,+    assistantPageFuncWrapper                ,+    mkAssistantPageFunc                     ,+    noAssistantPageFunc                     ,+++-- ** BuilderConnectFunc+    BuilderConnectFunc                      ,+    BuilderConnectFuncC                     ,+    builderConnectFuncClosure               ,+    builderConnectFuncWrapper               ,+    mkBuilderConnectFunc                    ,+    noBuilderConnectFunc                    ,+++-- ** CalendarDetailFunc+    CalendarDetailFunc                      ,+    CalendarDetailFuncC                     ,+    calendarDetailFuncClosure               ,+    calendarDetailFuncWrapper               ,+    mkCalendarDetailFunc                    ,+    noCalendarDetailFunc                    ,+++-- ** Callback+    Callback                                ,+    CallbackC                               ,+    callbackClosure                         ,+    callbackWrapper                         ,+    mkCallback                              ,+    noCallback                              ,+++-- ** CellAllocCallback+    CellAllocCallback                       ,+    CellAllocCallbackC                      ,+    cellAllocCallbackClosure                ,+    cellAllocCallbackWrapper                ,+    mkCellAllocCallback                     ,+    noCellAllocCallback                     ,+++-- ** CellCallback+    CellCallback                            ,+    CellCallbackC                           ,+    cellCallbackClosure                     ,+    cellCallbackWrapper                     ,+    mkCellCallback                          ,+    noCellCallback                          ,+++-- ** CellLayoutDataFunc+    CellLayoutDataFunc                      ,+    CellLayoutDataFuncC                     ,+    cellLayoutDataFuncClosure               ,+    cellLayoutDataFuncWrapper               ,+    mkCellLayoutDataFunc                    ,+    noCellLayoutDataFunc                    ,+++-- ** ClipboardClearFunc+    ClipboardClearFunc                      ,+    ClipboardClearFuncC                     ,+    clipboardClearFuncClosure               ,+    clipboardClearFuncWrapper               ,+    mkClipboardClearFunc                    ,+    noClipboardClearFunc                    ,+++-- ** ClipboardGetFunc+    ClipboardGetFunc                        ,+    ClipboardGetFuncC                       ,+    clipboardGetFuncClosure                 ,+    clipboardGetFuncWrapper                 ,+    mkClipboardGetFunc                      ,+    noClipboardGetFunc                      ,+++-- ** ClipboardImageReceivedFunc+    ClipboardImageReceivedFunc              ,+    ClipboardImageReceivedFuncC             ,+    clipboardImageReceivedFuncClosure       ,+    clipboardImageReceivedFuncWrapper       ,+    mkClipboardImageReceivedFunc            ,+    noClipboardImageReceivedFunc            ,+++-- ** ClipboardReceivedFunc+    ClipboardReceivedFunc                   ,+    ClipboardReceivedFuncC                  ,+    clipboardReceivedFuncClosure            ,+    clipboardReceivedFuncWrapper            ,+    mkClipboardReceivedFunc                 ,+    noClipboardReceivedFunc                 ,+++-- ** ClipboardRichTextReceivedFunc+    ClipboardRichTextReceivedFunc           ,+    ClipboardRichTextReceivedFuncC          ,+    clipboardRichTextReceivedFuncClosure    ,+    clipboardRichTextReceivedFuncWrapper    ,+    mkClipboardRichTextReceivedFunc         ,+    noClipboardRichTextReceivedFunc         ,+++-- ** ClipboardTargetsReceivedFunc+    ClipboardTargetsReceivedFunc            ,+    ClipboardTargetsReceivedFuncC           ,+    clipboardTargetsReceivedFuncClosure     ,+    clipboardTargetsReceivedFuncWrapper     ,+    mkClipboardTargetsReceivedFunc          ,+    noClipboardTargetsReceivedFunc          ,+++-- ** ClipboardTextReceivedFunc+    ClipboardTextReceivedFunc               ,+    ClipboardTextReceivedFuncC              ,+    clipboardTextReceivedFuncClosure        ,+    clipboardTextReceivedFuncWrapper        ,+    mkClipboardTextReceivedFunc             ,+    noClipboardTextReceivedFunc             ,+++-- ** ClipboardURIReceivedFunc+    ClipboardURIReceivedFunc                ,+    ClipboardURIReceivedFuncC               ,+    clipboardURIReceivedFuncClosure         ,+    clipboardURIReceivedFuncWrapper         ,+    mkClipboardURIReceivedFunc              ,+    noClipboardURIReceivedFunc              ,+++-- ** ColorSelectionChangePaletteFunc+    ColorSelectionChangePaletteFunc         ,+    ColorSelectionChangePaletteFuncC        ,+    colorSelectionChangePaletteFuncClosure  ,+    colorSelectionChangePaletteFuncWrapper  ,+    mkColorSelectionChangePaletteFunc       ,+    noColorSelectionChangePaletteFunc       ,+++-- ** ColorSelectionChangePaletteWithScreenFunc+    ColorSelectionChangePaletteWithScreenFunc,+    ColorSelectionChangePaletteWithScreenFuncC,+    colorSelectionChangePaletteWithScreenFuncClosure,+    colorSelectionChangePaletteWithScreenFuncWrapper,+    mkColorSelectionChangePaletteWithScreenFunc,+    noColorSelectionChangePaletteWithScreenFunc,+++-- ** EntryCompletionMatchFunc+    EntryCompletionMatchFunc                ,+    EntryCompletionMatchFuncC               ,+    entryCompletionMatchFuncClosure         ,+    entryCompletionMatchFuncWrapper         ,+    mkEntryCompletionMatchFunc              ,+    noEntryCompletionMatchFunc              ,+++-- ** FileFilterFunc+    FileFilterFunc                          ,+    FileFilterFuncC                         ,+    fileFilterFuncClosure                   ,+    fileFilterFuncWrapper                   ,+    mkFileFilterFunc                        ,+    noFileFilterFunc                        ,+++-- ** FlowBoxFilterFunc+    FlowBoxFilterFunc                       ,+    FlowBoxFilterFuncC                      ,+    flowBoxFilterFuncClosure                ,+    flowBoxFilterFuncWrapper                ,+    mkFlowBoxFilterFunc                     ,+    noFlowBoxFilterFunc                     ,+++-- ** FlowBoxForeachFunc+    FlowBoxForeachFunc                      ,+    FlowBoxForeachFuncC                     ,+    flowBoxForeachFuncClosure               ,+    flowBoxForeachFuncWrapper               ,+    mkFlowBoxForeachFunc                    ,+    noFlowBoxForeachFunc                    ,+++-- ** FlowBoxSortFunc+    FlowBoxSortFunc                         ,+    FlowBoxSortFuncC                        ,+    flowBoxSortFuncClosure                  ,+    flowBoxSortFuncWrapper                  ,+    mkFlowBoxSortFunc                       ,+    noFlowBoxSortFunc                       ,+++-- ** FontFilterFunc+    FontFilterFunc                          ,+    FontFilterFuncC                         ,+    fontFilterFuncClosure                   ,+    fontFilterFuncWrapper                   ,+    mkFontFilterFunc                        ,+    noFontFilterFunc                        ,+++-- ** IconViewForeachFunc+    IconViewForeachFunc                     ,+    IconViewForeachFuncC                    ,+    iconViewForeachFuncClosure              ,+    iconViewForeachFuncWrapper              ,+    mkIconViewForeachFunc                   ,+    noIconViewForeachFunc                   ,+++-- ** KeySnoopFunc+    KeySnoopFunc                            ,+    KeySnoopFuncC                           ,+    keySnoopFuncClosure                     ,+    keySnoopFuncWrapper                     ,+    mkKeySnoopFunc                          ,+    noKeySnoopFunc                          ,+++-- ** ListBoxCreateWidgetFunc+    ListBoxCreateWidgetFunc                 ,+    ListBoxCreateWidgetFuncC                ,+    listBoxCreateWidgetFuncClosure          ,+    listBoxCreateWidgetFuncWrapper          ,+    mkListBoxCreateWidgetFunc               ,+    noListBoxCreateWidgetFunc               ,+++-- ** ListBoxFilterFunc+    ListBoxFilterFunc                       ,+    ListBoxFilterFuncC                      ,+    listBoxFilterFuncClosure                ,+    listBoxFilterFuncWrapper                ,+    mkListBoxFilterFunc                     ,+    noListBoxFilterFunc                     ,+++-- ** ListBoxForeachFunc+    ListBoxForeachFunc                      ,+    ListBoxForeachFuncC                     ,+    listBoxForeachFuncClosure               ,+    listBoxForeachFuncWrapper               ,+    mkListBoxForeachFunc                    ,+    noListBoxForeachFunc                    ,+++-- ** ListBoxSortFunc+    ListBoxSortFunc                         ,+    ListBoxSortFuncC                        ,+    listBoxSortFuncClosure                  ,+    listBoxSortFuncWrapper                  ,+    mkListBoxSortFunc                       ,+    noListBoxSortFunc                       ,+++-- ** ListBoxUpdateHeaderFunc+    ListBoxUpdateHeaderFunc                 ,+    ListBoxUpdateHeaderFuncC                ,+    listBoxUpdateHeaderFuncClosure          ,+    listBoxUpdateHeaderFuncWrapper          ,+    mkListBoxUpdateHeaderFunc               ,+    noListBoxUpdateHeaderFunc               ,+++-- ** MenuDetachFunc+    MenuDetachFunc                          ,+    MenuDetachFuncC                         ,+    menuDetachFuncClosure                   ,+    menuDetachFuncWrapper                   ,+    mkMenuDetachFunc                        ,+    noMenuDetachFunc                        ,+++-- ** MenuPositionFunc+    MenuPositionFunc                        ,+    MenuPositionFuncC                       ,+    menuPositionFuncClosure                 ,+    menuPositionFuncWrapper                 ,+    mkMenuPositionFunc                      ,+    noMenuPositionFunc                      ,+++-- ** ModuleDisplayInitFunc+    ModuleDisplayInitFunc                   ,+    ModuleDisplayInitFuncC                  ,+    mkModuleDisplayInitFunc                 ,+    moduleDisplayInitFuncClosure            ,+    moduleDisplayInitFuncWrapper            ,+    noModuleDisplayInitFunc                 ,+++-- ** ModuleInitFunc+    ModuleInitFunc                          ,+    ModuleInitFuncC                         ,+    mkModuleInitFunc                        ,+    moduleInitFuncClosure                   ,+    moduleInitFuncWrapper                   ,+    noModuleInitFunc                        ,+++-- ** PageSetupDoneFunc+    PageSetupDoneFunc                       ,+    PageSetupDoneFuncC                      ,+    mkPageSetupDoneFunc                     ,+    noPageSetupDoneFunc                     ,+    pageSetupDoneFuncClosure                ,+    pageSetupDoneFuncWrapper                ,+++-- ** PrintSettingsFunc+    PrintSettingsFunc                       ,+    PrintSettingsFuncC                      ,+    mkPrintSettingsFunc                     ,+    noPrintSettingsFunc                     ,+    printSettingsFuncClosure                ,+    printSettingsFuncWrapper                ,+++-- ** RcPropertyParser+    RcPropertyParser                        ,+    RcPropertyParserC                       ,+    mkRcPropertyParser                      ,+    noRcPropertyParser                      ,+    rcPropertyParserClosure                 ,+    rcPropertyParserWrapper                 ,+++-- ** RecentFilterFunc+    RecentFilterFunc                        ,+    RecentFilterFuncC                       ,+    mkRecentFilterFunc                      ,+    noRecentFilterFunc                      ,+    recentFilterFuncClosure                 ,+    recentFilterFuncWrapper                 ,+++-- ** RecentSortFunc+    RecentSortFunc                          ,+    RecentSortFuncC                         ,+    mkRecentSortFunc                        ,+    noRecentSortFunc                        ,+    recentSortFuncClosure                   ,+    recentSortFuncWrapper                   ,+++-- ** StylePropertyParser+    StylePropertyParser                     ,+    StylePropertyParserC                    ,+    mkStylePropertyParser                   ,+    noStylePropertyParser                   ,+    stylePropertyParserClosure              ,+    stylePropertyParserWrapper              ,+++-- ** TextBufferDeserializeFunc+    TextBufferDeserializeFunc               ,+    TextBufferDeserializeFuncC              ,+    mkTextBufferDeserializeFunc             ,+    noTextBufferDeserializeFunc             ,+    textBufferDeserializeFuncClosure        ,+    textBufferDeserializeFuncWrapper        ,+++-- ** TextBufferSerializeFunc+    TextBufferSerializeFunc                 ,+    TextBufferSerializeFuncC                ,+    mkTextBufferSerializeFunc               ,+    noTextBufferSerializeFunc               ,+    textBufferSerializeFuncClosure          ,+    textBufferSerializeFuncWrapper          ,+++-- ** TextCharPredicate+    TextCharPredicate                       ,+    TextCharPredicateC                      ,+    mkTextCharPredicate                     ,+    noTextCharPredicate                     ,+    textCharPredicateClosure                ,+    textCharPredicateWrapper                ,+++-- ** TextTagTableForeach+    TextTagTableForeach                     ,+    TextTagTableForeachC                    ,+    mkTextTagTableForeach                   ,+    noTextTagTableForeach                   ,+    textTagTableForeachClosure              ,+    textTagTableForeachWrapper              ,+++-- ** TickCallback+    TickCallback                            ,+    TickCallbackC                           ,+    mkTickCallback                          ,+    noTickCallback                          ,+    tickCallbackClosure                     ,+    tickCallbackWrapper                     ,+++-- ** TranslateFunc+    TranslateFunc                           ,+    TranslateFuncC                          ,+    mkTranslateFunc                         ,+    noTranslateFunc                         ,+    translateFuncClosure                    ,+    translateFuncWrapper                    ,+++-- ** TreeCellDataFunc+    TreeCellDataFunc                        ,+    TreeCellDataFuncC                       ,+    mkTreeCellDataFunc                      ,+    noTreeCellDataFunc                      ,+    treeCellDataFuncClosure                 ,+    treeCellDataFuncWrapper                 ,+++-- ** TreeDestroyCountFunc+    TreeDestroyCountFunc                    ,+    TreeDestroyCountFuncC                   ,+    mkTreeDestroyCountFunc                  ,+    noTreeDestroyCountFunc                  ,+    treeDestroyCountFuncClosure             ,+    treeDestroyCountFuncWrapper             ,+++-- ** TreeIterCompareFunc+    TreeIterCompareFunc                     ,+    TreeIterCompareFuncC                    ,+    mkTreeIterCompareFunc                   ,+    noTreeIterCompareFunc                   ,+    treeIterCompareFuncClosure              ,+    treeIterCompareFuncWrapper              ,+++-- ** TreeModelFilterVisibleFunc+    TreeModelFilterVisibleFunc              ,+    TreeModelFilterVisibleFuncC             ,+    mkTreeModelFilterVisibleFunc            ,+    noTreeModelFilterVisibleFunc            ,+    treeModelFilterVisibleFuncClosure       ,+    treeModelFilterVisibleFuncWrapper       ,+++-- ** TreeModelForeachFunc+    TreeModelForeachFunc                    ,+    TreeModelForeachFuncC                   ,+    mkTreeModelForeachFunc                  ,+    noTreeModelForeachFunc                  ,+    treeModelForeachFuncClosure             ,+    treeModelForeachFuncWrapper             ,+++-- ** TreeSelectionForeachFunc+    TreeSelectionForeachFunc                ,+    TreeSelectionForeachFuncC               ,+    mkTreeSelectionForeachFunc              ,+    noTreeSelectionForeachFunc              ,+    treeSelectionForeachFuncClosure         ,+    treeSelectionForeachFuncWrapper         ,+++-- ** TreeSelectionFunc+    TreeSelectionFunc                       ,+    TreeSelectionFuncC                      ,+    mkTreeSelectionFunc                     ,+    noTreeSelectionFunc                     ,+    treeSelectionFuncClosure                ,+    treeSelectionFuncWrapper                ,+++-- ** TreeViewColumnDropFunc+    TreeViewColumnDropFunc                  ,+    TreeViewColumnDropFuncC                 ,+    mkTreeViewColumnDropFunc                ,+    noTreeViewColumnDropFunc                ,+    treeViewColumnDropFuncClosure           ,+    treeViewColumnDropFuncWrapper           ,+++-- ** TreeViewMappingFunc+    TreeViewMappingFunc                     ,+    TreeViewMappingFuncC                    ,+    mkTreeViewMappingFunc                   ,+    noTreeViewMappingFunc                   ,+    treeViewMappingFuncClosure              ,+    treeViewMappingFuncWrapper              ,+++-- ** TreeViewRowSeparatorFunc+    TreeViewRowSeparatorFunc                ,+    TreeViewRowSeparatorFuncC               ,+    mkTreeViewRowSeparatorFunc              ,+    noTreeViewRowSeparatorFunc              ,+    treeViewRowSeparatorFuncClosure         ,+    treeViewRowSeparatorFuncWrapper         ,+++-- ** TreeViewSearchEqualFunc+    TreeViewSearchEqualFunc                 ,+    TreeViewSearchEqualFuncC                ,+    mkTreeViewSearchEqualFunc               ,+    noTreeViewSearchEqualFunc               ,+    treeViewSearchEqualFuncClosure          ,+    treeViewSearchEqualFuncWrapper          ,+++-- ** TreeViewSearchPositionFunc+    TreeViewSearchPositionFunc              ,+    TreeViewSearchPositionFuncC             ,+    mkTreeViewSearchPositionFunc            ,+    noTreeViewSearchPositionFunc            ,+    treeViewSearchPositionFuncClosure       ,+    treeViewSearchPositionFuncWrapper       ,+++++    ) where++import Prelude ()+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.Gtk.Types++import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Pango as Pango++-- callback TreeViewSearchPositionFunc+treeViewSearchPositionFuncClosure :: TreeViewSearchPositionFunc -> IO Closure+treeViewSearchPositionFuncClosure cb = newCClosure =<< mkTreeViewSearchPositionFunc wrapped+    where wrapped = treeViewSearchPositionFuncWrapper Nothing cb++type TreeViewSearchPositionFuncC =+    Ptr TreeView ->+    Ptr Widget ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTreeViewSearchPositionFunc :: TreeViewSearchPositionFuncC -> IO (FunPtr TreeViewSearchPositionFuncC)++type TreeViewSearchPositionFunc =+    TreeView ->+    Widget ->+    IO ()++noTreeViewSearchPositionFunc :: Maybe TreeViewSearchPositionFunc+noTreeViewSearchPositionFunc = Nothing++treeViewSearchPositionFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeViewSearchPositionFuncC))) ->+    TreeViewSearchPositionFunc ->+    Ptr TreeView ->+    Ptr Widget ->+    Ptr () ->+    IO ()+treeViewSearchPositionFuncWrapper funptrptr _cb tree_view search_dialog _ = do+    tree_view' <- (newObject TreeView) tree_view+    search_dialog' <- (newObject Widget) search_dialog+    _cb  tree_view' search_dialog'+    maybeReleaseFunPtr funptrptr++-- callback TreeViewSearchEqualFunc+treeViewSearchEqualFuncClosure :: TreeViewSearchEqualFunc -> IO Closure+treeViewSearchEqualFuncClosure cb = newCClosure =<< mkTreeViewSearchEqualFunc wrapped+    where wrapped = treeViewSearchEqualFuncWrapper Nothing cb++type TreeViewSearchEqualFuncC =+    Ptr TreeModel ->+    Int32 ->+    CString ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeViewSearchEqualFunc :: TreeViewSearchEqualFuncC -> IO (FunPtr TreeViewSearchEqualFuncC)++type TreeViewSearchEqualFunc =+    TreeModel ->+    Int32 ->+    T.Text ->+    TreeIter ->+    IO Bool++noTreeViewSearchEqualFunc :: Maybe TreeViewSearchEqualFunc+noTreeViewSearchEqualFunc = Nothing++treeViewSearchEqualFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeViewSearchEqualFuncC))) ->+    TreeViewSearchEqualFunc ->+    Ptr TreeModel ->+    Int32 ->+    CString ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+treeViewSearchEqualFuncWrapper funptrptr _cb model column key iter _ = do+    model' <- (newObject TreeModel) model+    key' <- cstringToText key+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' column key' iter'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeViewRowSeparatorFunc+treeViewRowSeparatorFuncClosure :: TreeViewRowSeparatorFunc -> IO Closure+treeViewRowSeparatorFuncClosure cb = newCClosure =<< mkTreeViewRowSeparatorFunc wrapped+    where wrapped = treeViewRowSeparatorFuncWrapper Nothing cb++type TreeViewRowSeparatorFuncC =+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeViewRowSeparatorFunc :: TreeViewRowSeparatorFuncC -> IO (FunPtr TreeViewRowSeparatorFuncC)++type TreeViewRowSeparatorFunc =+    TreeModel ->+    TreeIter ->+    IO Bool++noTreeViewRowSeparatorFunc :: Maybe TreeViewRowSeparatorFunc+noTreeViewRowSeparatorFunc = Nothing++treeViewRowSeparatorFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeViewRowSeparatorFuncC))) ->+    TreeViewRowSeparatorFunc ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+treeViewRowSeparatorFuncWrapper funptrptr _cb model iter _ = do+    model' <- (newObject TreeModel) model+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' iter'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeViewMappingFunc+treeViewMappingFuncClosure :: TreeViewMappingFunc -> IO Closure+treeViewMappingFuncClosure cb = newCClosure =<< mkTreeViewMappingFunc wrapped+    where wrapped = treeViewMappingFuncWrapper Nothing cb++type TreeViewMappingFuncC =+    Ptr TreeView ->+    Ptr TreePath ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTreeViewMappingFunc :: TreeViewMappingFuncC -> IO (FunPtr TreeViewMappingFuncC)++type TreeViewMappingFunc =+    TreeView ->+    TreePath ->+    IO ()++noTreeViewMappingFunc :: Maybe TreeViewMappingFunc+noTreeViewMappingFunc = Nothing++treeViewMappingFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeViewMappingFuncC))) ->+    TreeViewMappingFunc ->+    Ptr TreeView ->+    Ptr TreePath ->+    Ptr () ->+    IO ()+treeViewMappingFuncWrapper funptrptr _cb tree_view path _ = do+    tree_view' <- (newObject TreeView) tree_view+    path' <- (newBoxed TreePath) path+    _cb  tree_view' path'+    maybeReleaseFunPtr funptrptr++-- callback TreeViewColumnDropFunc+treeViewColumnDropFuncClosure :: TreeViewColumnDropFunc -> IO Closure+treeViewColumnDropFuncClosure cb = newCClosure =<< mkTreeViewColumnDropFunc wrapped+    where wrapped = treeViewColumnDropFuncWrapper Nothing cb++type TreeViewColumnDropFuncC =+    Ptr TreeView ->+    Ptr TreeViewColumn ->+    Ptr TreeViewColumn ->+    Ptr TreeViewColumn ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeViewColumnDropFunc :: TreeViewColumnDropFuncC -> IO (FunPtr TreeViewColumnDropFuncC)++type TreeViewColumnDropFunc =+    TreeView ->+    TreeViewColumn ->+    TreeViewColumn ->+    TreeViewColumn ->+    IO Bool++noTreeViewColumnDropFunc :: Maybe TreeViewColumnDropFunc+noTreeViewColumnDropFunc = Nothing++treeViewColumnDropFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeViewColumnDropFuncC))) ->+    TreeViewColumnDropFunc ->+    Ptr TreeView ->+    Ptr TreeViewColumn ->+    Ptr TreeViewColumn ->+    Ptr TreeViewColumn ->+    Ptr () ->+    IO CInt+treeViewColumnDropFuncWrapper funptrptr _cb tree_view column prev_column next_column _ = do+    tree_view' <- (newObject TreeView) tree_view+    column' <- (newObject TreeViewColumn) column+    prev_column' <- (newObject TreeViewColumn) prev_column+    next_column' <- (newObject TreeViewColumn) next_column+    result <- _cb  tree_view' column' prev_column' next_column'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeSelectionFunc+treeSelectionFuncClosure :: TreeSelectionFunc -> IO Closure+treeSelectionFuncClosure cb = newCClosure =<< mkTreeSelectionFunc wrapped+    where wrapped = treeSelectionFuncWrapper Nothing cb++type TreeSelectionFuncC =+    Ptr TreeSelection ->+    Ptr TreeModel ->+    Ptr TreePath ->+    CInt ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeSelectionFunc :: TreeSelectionFuncC -> IO (FunPtr TreeSelectionFuncC)++type TreeSelectionFunc =+    TreeSelection ->+    TreeModel ->+    TreePath ->+    Bool ->+    IO Bool++noTreeSelectionFunc :: Maybe TreeSelectionFunc+noTreeSelectionFunc = Nothing++treeSelectionFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeSelectionFuncC))) ->+    TreeSelectionFunc ->+    Ptr TreeSelection ->+    Ptr TreeModel ->+    Ptr TreePath ->+    CInt ->+    Ptr () ->+    IO CInt+treeSelectionFuncWrapper funptrptr _cb selection model path path_currently_selected _ = do+    selection' <- (newObject TreeSelection) selection+    model' <- (newObject TreeModel) model+    path' <- (newBoxed TreePath) path+    let path_currently_selected' = (/= 0) path_currently_selected+    result <- _cb  selection' model' path' path_currently_selected'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeSelectionForeachFunc+treeSelectionForeachFuncClosure :: TreeSelectionForeachFunc -> IO Closure+treeSelectionForeachFuncClosure cb = newCClosure =<< mkTreeSelectionForeachFunc wrapped+    where wrapped = treeSelectionForeachFuncWrapper Nothing cb++type TreeSelectionForeachFuncC =+    Ptr TreeModel ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTreeSelectionForeachFunc :: TreeSelectionForeachFuncC -> IO (FunPtr TreeSelectionForeachFuncC)++type TreeSelectionForeachFunc =+    TreeModel ->+    TreePath ->+    TreeIter ->+    IO ()++noTreeSelectionForeachFunc :: Maybe TreeSelectionForeachFunc+noTreeSelectionForeachFunc = Nothing++treeSelectionForeachFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeSelectionForeachFuncC))) ->+    TreeSelectionForeachFunc ->+    Ptr TreeModel ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+treeSelectionForeachFuncWrapper funptrptr _cb model path iter _ = do+    model' <- (newObject TreeModel) model+    path' <- (newBoxed TreePath) path+    iter' <- (newBoxed TreeIter) iter+    _cb  model' path' iter'+    maybeReleaseFunPtr funptrptr++-- callback TreeModelForeachFunc+treeModelForeachFuncClosure :: TreeModelForeachFunc -> IO Closure+treeModelForeachFuncClosure cb = newCClosure =<< mkTreeModelForeachFunc wrapped+    where wrapped = treeModelForeachFuncWrapper Nothing cb++type TreeModelForeachFuncC =+    Ptr TreeModel ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeModelForeachFunc :: TreeModelForeachFuncC -> IO (FunPtr TreeModelForeachFuncC)++type TreeModelForeachFunc =+    TreeModel ->+    TreePath ->+    TreeIter ->+    IO Bool++noTreeModelForeachFunc :: Maybe TreeModelForeachFunc+noTreeModelForeachFunc = Nothing++treeModelForeachFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeModelForeachFuncC))) ->+    TreeModelForeachFunc ->+    Ptr TreeModel ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+treeModelForeachFuncWrapper funptrptr _cb model path iter _ = do+    model' <- (newObject TreeModel) model+    path' <- (newBoxed TreePath) path+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' path' iter'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeModelFilterVisibleFunc+treeModelFilterVisibleFuncClosure :: TreeModelFilterVisibleFunc -> IO Closure+treeModelFilterVisibleFuncClosure cb = newCClosure =<< mkTreeModelFilterVisibleFunc wrapped+    where wrapped = treeModelFilterVisibleFuncWrapper Nothing cb++type TreeModelFilterVisibleFuncC =+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTreeModelFilterVisibleFunc :: TreeModelFilterVisibleFuncC -> IO (FunPtr TreeModelFilterVisibleFuncC)++type TreeModelFilterVisibleFunc =+    TreeModel ->+    TreeIter ->+    IO Bool++noTreeModelFilterVisibleFunc :: Maybe TreeModelFilterVisibleFunc+noTreeModelFilterVisibleFunc = Nothing++treeModelFilterVisibleFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeModelFilterVisibleFuncC))) ->+    TreeModelFilterVisibleFunc ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+treeModelFilterVisibleFuncWrapper funptrptr _cb model iter _ = do+    model' <- (newObject TreeModel) model+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' iter'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TreeModelFilterModifyFunc+-- XXX Could not generate callback wrapper for TreeModelFilterModifyFunc+-- Error was : Not implemented: "Unexpected transfer type for \"value\""+-- callback TreeIterCompareFunc+treeIterCompareFuncClosure :: TreeIterCompareFunc -> IO Closure+treeIterCompareFuncClosure cb = newCClosure =<< mkTreeIterCompareFunc wrapped+    where wrapped = treeIterCompareFuncWrapper Nothing cb++type TreeIterCompareFuncC =+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr TreeIter ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkTreeIterCompareFunc :: TreeIterCompareFuncC -> IO (FunPtr TreeIterCompareFuncC)++type TreeIterCompareFunc =+    TreeModel ->+    TreeIter ->+    TreeIter ->+    IO Int32++noTreeIterCompareFunc :: Maybe TreeIterCompareFunc+noTreeIterCompareFunc = Nothing++treeIterCompareFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeIterCompareFuncC))) ->+    TreeIterCompareFunc ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr TreeIter ->+    Ptr () ->+    IO Int32+treeIterCompareFuncWrapper funptrptr _cb model a b _ = do+    model' <- (newObject TreeModel) model+    a' <- (newBoxed TreeIter) a+    b' <- (newBoxed TreeIter) b+    result <- _cb  model' a' b'+    maybeReleaseFunPtr funptrptr+    return result++-- callback TreeDestroyCountFunc+treeDestroyCountFuncClosure :: TreeDestroyCountFunc -> IO Closure+treeDestroyCountFuncClosure cb = newCClosure =<< mkTreeDestroyCountFunc wrapped+    where wrapped = treeDestroyCountFuncWrapper Nothing cb++type TreeDestroyCountFuncC =+    Ptr TreeView ->+    Ptr TreePath ->+    Int32 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTreeDestroyCountFunc :: TreeDestroyCountFuncC -> IO (FunPtr TreeDestroyCountFuncC)++type TreeDestroyCountFunc =+    TreeView ->+    TreePath ->+    Int32 ->+    IO ()++noTreeDestroyCountFunc :: Maybe TreeDestroyCountFunc+noTreeDestroyCountFunc = Nothing++treeDestroyCountFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeDestroyCountFuncC))) ->+    TreeDestroyCountFunc ->+    Ptr TreeView ->+    Ptr TreePath ->+    Int32 ->+    Ptr () ->+    IO ()+treeDestroyCountFuncWrapper funptrptr _cb tree_view path children _ = do+    tree_view' <- (newObject TreeView) tree_view+    path' <- (newBoxed TreePath) path+    _cb  tree_view' path' children+    maybeReleaseFunPtr funptrptr++-- callback TreeCellDataFunc+treeCellDataFuncClosure :: TreeCellDataFunc -> IO Closure+treeCellDataFuncClosure cb = newCClosure =<< mkTreeCellDataFunc wrapped+    where wrapped = treeCellDataFuncWrapper Nothing cb++type TreeCellDataFuncC =+    Ptr TreeViewColumn ->+    Ptr CellRenderer ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTreeCellDataFunc :: TreeCellDataFuncC -> IO (FunPtr TreeCellDataFuncC)++type TreeCellDataFunc =+    TreeViewColumn ->+    CellRenderer ->+    TreeModel ->+    TreeIter ->+    IO ()++noTreeCellDataFunc :: Maybe TreeCellDataFunc+noTreeCellDataFunc = Nothing++treeCellDataFuncWrapper ::+    Maybe (Ptr (FunPtr (TreeCellDataFuncC))) ->+    TreeCellDataFunc ->+    Ptr TreeViewColumn ->+    Ptr CellRenderer ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+treeCellDataFuncWrapper funptrptr _cb tree_column cell tree_model iter _ = do+    tree_column' <- (newObject TreeViewColumn) tree_column+    cell' <- (newObject CellRenderer) cell+    tree_model' <- (newObject TreeModel) tree_model+    iter' <- (newBoxed TreeIter) iter+    _cb  tree_column' cell' tree_model' iter'+    maybeReleaseFunPtr funptrptr++-- callback TranslateFunc+translateFuncClosure :: TranslateFunc -> IO Closure+translateFuncClosure cb = newCClosure =<< mkTranslateFunc wrapped+    where wrapped = translateFuncWrapper Nothing cb++type TranslateFuncC =+    CString ->+    Ptr () ->+    IO CString++foreign import ccall "wrapper"+    mkTranslateFunc :: TranslateFuncC -> IO (FunPtr TranslateFuncC)++type TranslateFunc =+    T.Text ->+    IO T.Text++noTranslateFunc :: Maybe TranslateFunc+noTranslateFunc = Nothing++translateFuncWrapper ::+    Maybe (Ptr (FunPtr (TranslateFuncC))) ->+    TranslateFunc ->+    CString ->+    Ptr () ->+    IO CString+translateFuncWrapper funptrptr _cb path _ = do+    path' <- cstringToText path+    result <- _cb  path'+    maybeReleaseFunPtr funptrptr+    result' <- textToCString result+    return result'++-- callback TickCallback+tickCallbackClosure :: TickCallback -> IO Closure+tickCallbackClosure cb = newCClosure =<< mkTickCallback wrapped+    where wrapped = tickCallbackWrapper Nothing cb++type TickCallbackC =+    Ptr Widget ->+    Ptr Gdk.FrameClock ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTickCallback :: TickCallbackC -> IO (FunPtr TickCallbackC)++type TickCallback =+    Widget ->+    Gdk.FrameClock ->+    IO Bool++noTickCallback :: Maybe TickCallback+noTickCallback = Nothing++tickCallbackWrapper ::+    Maybe (Ptr (FunPtr (TickCallbackC))) ->+    TickCallback ->+    Ptr Widget ->+    Ptr Gdk.FrameClock ->+    Ptr () ->+    IO CInt+tickCallbackWrapper funptrptr _cb widget frame_clock _ = do+    widget' <- (newObject Widget) widget+    frame_clock' <- (newObject Gdk.FrameClock) frame_clock+    result <- _cb  widget' frame_clock'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TextTagTableForeach+textTagTableForeachClosure :: TextTagTableForeach -> IO Closure+textTagTableForeachClosure cb = newCClosure =<< mkTextTagTableForeach wrapped+    where wrapped = textTagTableForeachWrapper Nothing cb++type TextTagTableForeachC =+    Ptr TextTag ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkTextTagTableForeach :: TextTagTableForeachC -> IO (FunPtr TextTagTableForeachC)++type TextTagTableForeach =+    TextTag ->+    IO ()++noTextTagTableForeach :: Maybe TextTagTableForeach+noTextTagTableForeach = Nothing++textTagTableForeachWrapper ::+    Maybe (Ptr (FunPtr (TextTagTableForeachC))) ->+    TextTagTableForeach ->+    Ptr TextTag ->+    Ptr () ->+    IO ()+textTagTableForeachWrapper funptrptr _cb tag _ = do+    tag' <- (newObject TextTag) tag+    _cb  tag'+    maybeReleaseFunPtr funptrptr++-- callback TextCharPredicate+textCharPredicateClosure :: TextCharPredicate -> IO Closure+textCharPredicateClosure cb = newCClosure =<< mkTextCharPredicate wrapped+    where wrapped = textCharPredicateWrapper Nothing cb++type TextCharPredicateC =+    CInt ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTextCharPredicate :: TextCharPredicateC -> IO (FunPtr TextCharPredicateC)++type TextCharPredicate =+    Char ->+    IO Bool++noTextCharPredicate :: Maybe TextCharPredicate+noTextCharPredicate = Nothing++textCharPredicateWrapper ::+    Maybe (Ptr (FunPtr (TextCharPredicateC))) ->+    TextCharPredicate ->+    CInt ->+    Ptr () ->+    IO CInt+textCharPredicateWrapper funptrptr _cb ch _ = do+    let ch' = (chr . fromIntegral) ch+    result <- _cb  ch'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback TextBufferSerializeFunc+textBufferSerializeFuncClosure :: TextBufferSerializeFunc -> IO Closure+textBufferSerializeFuncClosure cb = newCClosure =<< mkTextBufferSerializeFunc wrapped+    where wrapped = textBufferSerializeFuncWrapper Nothing cb++type TextBufferSerializeFuncC =+    Ptr TextBuffer ->+    Ptr TextBuffer ->+    Ptr TextIter ->+    Ptr TextIter ->+    Word64 ->+    Ptr () ->+    IO Word8++foreign import ccall "wrapper"+    mkTextBufferSerializeFunc :: TextBufferSerializeFuncC -> IO (FunPtr TextBufferSerializeFuncC)++type TextBufferSerializeFunc =+    TextBuffer ->+    TextBuffer ->+    TextIter ->+    TextIter ->+    Word64 ->+    IO Word8++noTextBufferSerializeFunc :: Maybe TextBufferSerializeFunc+noTextBufferSerializeFunc = Nothing++textBufferSerializeFuncWrapper ::+    Maybe (Ptr (FunPtr (TextBufferSerializeFuncC))) ->+    TextBufferSerializeFunc ->+    Ptr TextBuffer ->+    Ptr TextBuffer ->+    Ptr TextIter ->+    Ptr TextIter ->+    Word64 ->+    Ptr () ->+    IO Word8+textBufferSerializeFuncWrapper funptrptr _cb register_buffer content_buffer start end length_ _ = do+    register_buffer' <- (newObject TextBuffer) register_buffer+    content_buffer' <- (newObject TextBuffer) content_buffer+    start' <- (newBoxed TextIter) start+    end' <- (newBoxed TextIter) end+    result <- _cb  register_buffer' content_buffer' start' end' length_+    maybeReleaseFunPtr funptrptr+    return result++-- callback TextBufferDeserializeFunc+textBufferDeserializeFuncClosure :: TextBufferDeserializeFunc -> IO Closure+textBufferDeserializeFuncClosure cb = newCClosure =<< mkTextBufferDeserializeFunc wrapped+    where wrapped = textBufferDeserializeFuncWrapper Nothing cb++type TextBufferDeserializeFuncC =+    Ptr TextBuffer ->+    Ptr TextBuffer ->+    Ptr TextIter ->+    Ptr Word8 ->+    Word64 ->+    CInt ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkTextBufferDeserializeFunc :: TextBufferDeserializeFuncC -> IO (FunPtr TextBufferDeserializeFuncC)++type TextBufferDeserializeFunc =+    TextBuffer ->+    TextBuffer ->+    TextIter ->+    ByteString ->+    Bool ->+    IO Bool++noTextBufferDeserializeFunc :: Maybe TextBufferDeserializeFunc+noTextBufferDeserializeFunc = Nothing++textBufferDeserializeFuncWrapper ::+    Maybe (Ptr (FunPtr (TextBufferDeserializeFuncC))) ->+    TextBufferDeserializeFunc ->+    Ptr TextBuffer ->+    Ptr TextBuffer ->+    Ptr TextIter ->+    Ptr Word8 ->+    Word64 ->+    CInt ->+    Ptr () ->+    IO CInt+textBufferDeserializeFuncWrapper funptrptr _cb register_buffer content_buffer iter data_ length_ create_tags _ = do+    register_buffer' <- (newObject TextBuffer) register_buffer+    content_buffer' <- (newObject TextBuffer) content_buffer+    iter' <- (newBoxed TextIter) iter+    data_' <- (unpackByteStringWithLength length_) data_+    let create_tags' = (/= 0) create_tags+    result <- _cb  register_buffer' content_buffer' iter' data_' create_tags'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback StylePropertyParser+stylePropertyParserClosure :: StylePropertyParser -> IO Closure+stylePropertyParserClosure cb = newCClosure =<< mkStylePropertyParser wrapped+    where wrapped = stylePropertyParserWrapper Nothing cb++type StylePropertyParserC =+    CString ->+    Ptr GValue ->+    IO CInt++foreign import ccall "wrapper"+    mkStylePropertyParser :: StylePropertyParserC -> IO (FunPtr StylePropertyParserC)++type StylePropertyParser =+    T.Text ->+    GValue ->+    IO Bool++noStylePropertyParser :: Maybe StylePropertyParser+noStylePropertyParser = Nothing++stylePropertyParserWrapper ::+    Maybe (Ptr (FunPtr (StylePropertyParserC))) ->+    StylePropertyParser ->+    CString ->+    Ptr GValue ->+    IO CInt+stylePropertyParserWrapper funptrptr _cb string value = do+    string' <- cstringToText string+    value' <- (newBoxed GValue) value+    result <- _cb  string' value'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback RecentSortFunc+recentSortFuncClosure :: RecentSortFunc -> IO Closure+recentSortFuncClosure cb = newCClosure =<< mkRecentSortFunc wrapped+    where wrapped = recentSortFuncWrapper Nothing cb++type RecentSortFuncC =+    Ptr RecentInfo ->+    Ptr RecentInfo ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkRecentSortFunc :: RecentSortFuncC -> IO (FunPtr RecentSortFuncC)++type RecentSortFunc =+    RecentInfo ->+    RecentInfo ->+    IO Int32++noRecentSortFunc :: Maybe RecentSortFunc+noRecentSortFunc = Nothing++recentSortFuncWrapper ::+    Maybe (Ptr (FunPtr (RecentSortFuncC))) ->+    RecentSortFunc ->+    Ptr RecentInfo ->+    Ptr RecentInfo ->+    Ptr () ->+    IO Int32+recentSortFuncWrapper funptrptr _cb a b _ = do+    a' <- (newBoxed RecentInfo) a+    b' <- (newBoxed RecentInfo) b+    result <- _cb  a' b'+    maybeReleaseFunPtr funptrptr+    return result++-- callback RecentFilterFunc+recentFilterFuncClosure :: RecentFilterFunc -> IO Closure+recentFilterFuncClosure cb = newCClosure =<< mkRecentFilterFunc wrapped+    where wrapped = recentFilterFuncWrapper Nothing cb++type RecentFilterFuncC =+    Ptr RecentFilterInfo ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkRecentFilterFunc :: RecentFilterFuncC -> IO (FunPtr RecentFilterFuncC)++type RecentFilterFunc =+    RecentFilterInfo ->+    IO Bool++noRecentFilterFunc :: Maybe RecentFilterFunc+noRecentFilterFunc = Nothing++recentFilterFuncWrapper ::+    Maybe (Ptr (FunPtr (RecentFilterFuncC))) ->+    RecentFilterFunc ->+    Ptr RecentFilterInfo ->+    Ptr () ->+    IO CInt+recentFilterFuncWrapper funptrptr _cb filter_info _ = do+    filter_info' <- (newPtr 56 RecentFilterInfo) filter_info+    result <- _cb  filter_info'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback RcPropertyParser+rcPropertyParserClosure :: RcPropertyParser -> IO Closure+rcPropertyParserClosure cb = newCClosure =<< mkRcPropertyParser wrapped+    where wrapped = rcPropertyParserWrapper Nothing cb++type RcPropertyParserC =+    Ptr GParamSpec ->+    Ptr GLib.String ->+    Ptr GValue ->+    IO CInt++foreign import ccall "wrapper"+    mkRcPropertyParser :: RcPropertyParserC -> IO (FunPtr RcPropertyParserC)++type RcPropertyParser =+    GParamSpec ->+    GLib.String ->+    GValue ->+    IO Bool++noRcPropertyParser :: Maybe RcPropertyParser+noRcPropertyParser = Nothing++rcPropertyParserWrapper ::+    Maybe (Ptr (FunPtr (RcPropertyParserC))) ->+    RcPropertyParser ->+    Ptr GParamSpec ->+    Ptr GLib.String ->+    Ptr GValue ->+    IO CInt+rcPropertyParserWrapper funptrptr _cb pspec rc_string property_value = do+    pspec' <- newGParamSpecFromPtr pspec+    rc_string' <- (newBoxed GLib.String) rc_string+    property_value' <- (newBoxed GValue) property_value+    result <- _cb  pspec' rc_string' property_value'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback PrintSettingsFunc+printSettingsFuncClosure :: PrintSettingsFunc -> IO Closure+printSettingsFuncClosure cb = newCClosure =<< mkPrintSettingsFunc wrapped+    where wrapped = printSettingsFuncWrapper Nothing cb++type PrintSettingsFuncC =+    CString ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkPrintSettingsFunc :: PrintSettingsFuncC -> IO (FunPtr PrintSettingsFuncC)++type PrintSettingsFunc =+    T.Text ->+    T.Text ->+    IO ()++noPrintSettingsFunc :: Maybe PrintSettingsFunc+noPrintSettingsFunc = Nothing++printSettingsFuncWrapper ::+    Maybe (Ptr (FunPtr (PrintSettingsFuncC))) ->+    PrintSettingsFunc ->+    CString ->+    CString ->+    Ptr () ->+    IO ()+printSettingsFuncWrapper funptrptr _cb key value _ = do+    key' <- cstringToText key+    value' <- cstringToText value+    _cb  key' value'+    maybeReleaseFunPtr funptrptr++-- callback PageSetupDoneFunc+pageSetupDoneFuncClosure :: PageSetupDoneFunc -> IO Closure+pageSetupDoneFuncClosure cb = newCClosure =<< mkPageSetupDoneFunc wrapped+    where wrapped = pageSetupDoneFuncWrapper Nothing cb++type PageSetupDoneFuncC =+    Ptr PageSetup ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkPageSetupDoneFunc :: PageSetupDoneFuncC -> IO (FunPtr PageSetupDoneFuncC)++type PageSetupDoneFunc =+    PageSetup ->+    IO ()++noPageSetupDoneFunc :: Maybe PageSetupDoneFunc+noPageSetupDoneFunc = Nothing++pageSetupDoneFuncWrapper ::+    Maybe (Ptr (FunPtr (PageSetupDoneFuncC))) ->+    PageSetupDoneFunc ->+    Ptr PageSetup ->+    Ptr () ->+    IO ()+pageSetupDoneFuncWrapper funptrptr _cb page_setup _ = do+    page_setup' <- (newObject PageSetup) page_setup+    _cb  page_setup'+    maybeReleaseFunPtr funptrptr++-- callback ModuleInitFunc+moduleInitFuncClosure :: ModuleInitFunc -> IO Closure+moduleInitFuncClosure cb = newCClosure =<< mkModuleInitFunc wrapped+    where wrapped = moduleInitFuncWrapper Nothing cb++type ModuleInitFuncC =+    Int32 ->+    Ptr CString ->+    IO ()++foreign import ccall "wrapper"+    mkModuleInitFunc :: ModuleInitFuncC -> IO (FunPtr ModuleInitFuncC)++type ModuleInitFunc =+    Maybe [T.Text] ->+    IO ()++noModuleInitFunc :: Maybe ModuleInitFunc+noModuleInitFunc = Nothing++moduleInitFuncWrapper ::+    Maybe (Ptr (FunPtr (ModuleInitFuncC))) ->+    ModuleInitFunc ->+    Int32 ->+    Ptr CString ->+    IO ()+moduleInitFuncWrapper funptrptr _cb argc argv = do+    maybeArgv <-+        if argv == nullPtr+        then return Nothing+        else do+            argv' <- (unpackUTF8CArrayWithLength argc) argv+            return $ Just argv'+    _cb  maybeArgv+    maybeReleaseFunPtr funptrptr++-- callback ModuleDisplayInitFunc+moduleDisplayInitFuncClosure :: ModuleDisplayInitFunc -> IO Closure+moduleDisplayInitFuncClosure cb = newCClosure =<< mkModuleDisplayInitFunc wrapped+    where wrapped = moduleDisplayInitFuncWrapper Nothing cb++type ModuleDisplayInitFuncC =+    Ptr Gdk.Display ->+    IO ()++foreign import ccall "wrapper"+    mkModuleDisplayInitFunc :: ModuleDisplayInitFuncC -> IO (FunPtr ModuleDisplayInitFuncC)++type ModuleDisplayInitFunc =+    Gdk.Display ->+    IO ()++noModuleDisplayInitFunc :: Maybe ModuleDisplayInitFunc+noModuleDisplayInitFunc = Nothing++moduleDisplayInitFuncWrapper ::+    Maybe (Ptr (FunPtr (ModuleDisplayInitFuncC))) ->+    ModuleDisplayInitFunc ->+    Ptr Gdk.Display ->+    IO ()+moduleDisplayInitFuncWrapper funptrptr _cb display = do+    display' <- (newObject Gdk.Display) display+    _cb  display'+    maybeReleaseFunPtr funptrptr++-- callback MenuPositionFunc+menuPositionFuncClosure :: MenuPositionFunc -> IO Closure+menuPositionFuncClosure cb = newCClosure =<< mkMenuPositionFunc wrapped+    where wrapped = menuPositionFuncWrapper Nothing cb++type MenuPositionFuncC =+    Ptr Menu ->+    Ptr Int32 ->+    Ptr Int32 ->+    Ptr CInt ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkMenuPositionFunc :: MenuPositionFuncC -> IO (FunPtr MenuPositionFuncC)++type MenuPositionFunc =+    Menu ->+    Int32 ->+    Int32 ->+    IO (Int32,Int32,Bool)++noMenuPositionFunc :: Maybe MenuPositionFunc+noMenuPositionFunc = Nothing++menuPositionFuncWrapper ::+    Maybe (Ptr (FunPtr (MenuPositionFuncC))) ->+    MenuPositionFunc ->+    Ptr Menu ->+    Ptr Int32 ->+    Ptr Int32 ->+    Ptr CInt ->+    Ptr () ->+    IO ()+menuPositionFuncWrapper funptrptr _cb menu x y push_in _ = do+    menu' <- (newObject Menu) menu+    x' <- peek x+    y' <- peek y+    (outx, outy, outpush_in) <- _cb  menu' x' y'+    poke x outx+    poke y outy+    let outpush_in' = (fromIntegral . fromEnum) outpush_in+    poke push_in outpush_in'+    maybeReleaseFunPtr funptrptr++-- callback MenuDetachFunc+menuDetachFuncClosure :: MenuDetachFunc -> IO Closure+menuDetachFuncClosure cb = newCClosure =<< mkMenuDetachFunc wrapped+    where wrapped = menuDetachFuncWrapper Nothing cb++type MenuDetachFuncC =+    Ptr Widget ->+    Ptr Menu ->+    IO ()++foreign import ccall "wrapper"+    mkMenuDetachFunc :: MenuDetachFuncC -> IO (FunPtr MenuDetachFuncC)++type MenuDetachFunc =+    Widget ->+    Menu ->+    IO ()++noMenuDetachFunc :: Maybe MenuDetachFunc+noMenuDetachFunc = Nothing++menuDetachFuncWrapper ::+    Maybe (Ptr (FunPtr (MenuDetachFuncC))) ->+    MenuDetachFunc ->+    Ptr Widget ->+    Ptr Menu ->+    IO ()+menuDetachFuncWrapper funptrptr _cb attach_widget menu = do+    attach_widget' <- (newObject Widget) attach_widget+    menu' <- (newObject Menu) menu+    _cb  attach_widget' menu'+    maybeReleaseFunPtr funptrptr++-- callback ListBoxUpdateHeaderFunc+listBoxUpdateHeaderFuncClosure :: ListBoxUpdateHeaderFunc -> IO Closure+listBoxUpdateHeaderFuncClosure cb = newCClosure =<< mkListBoxUpdateHeaderFunc wrapped+    where wrapped = listBoxUpdateHeaderFuncWrapper Nothing cb++type ListBoxUpdateHeaderFuncC =+    Ptr ListBoxRow ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkListBoxUpdateHeaderFunc :: ListBoxUpdateHeaderFuncC -> IO (FunPtr ListBoxUpdateHeaderFuncC)++type ListBoxUpdateHeaderFunc =+    ListBoxRow ->+    Maybe ListBoxRow ->+    IO ()++noListBoxUpdateHeaderFunc :: Maybe ListBoxUpdateHeaderFunc+noListBoxUpdateHeaderFunc = Nothing++listBoxUpdateHeaderFuncWrapper ::+    Maybe (Ptr (FunPtr (ListBoxUpdateHeaderFuncC))) ->+    ListBoxUpdateHeaderFunc ->+    Ptr ListBoxRow ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()+listBoxUpdateHeaderFuncWrapper funptrptr _cb row before _ = do+    row' <- (newObject ListBoxRow) row+    maybeBefore <-+        if before == nullPtr+        then return Nothing+        else do+            before' <- (newObject ListBoxRow) before+            return $ Just before'+    _cb  row' maybeBefore+    maybeReleaseFunPtr funptrptr++-- callback ListBoxSortFunc+listBoxSortFuncClosure :: ListBoxSortFunc -> IO Closure+listBoxSortFuncClosure cb = newCClosure =<< mkListBoxSortFunc wrapped+    where wrapped = listBoxSortFuncWrapper Nothing cb++type ListBoxSortFuncC =+    Ptr ListBoxRow ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkListBoxSortFunc :: ListBoxSortFuncC -> IO (FunPtr ListBoxSortFuncC)++type ListBoxSortFunc =+    ListBoxRow ->+    ListBoxRow ->+    IO Int32++noListBoxSortFunc :: Maybe ListBoxSortFunc+noListBoxSortFunc = Nothing++listBoxSortFuncWrapper ::+    Maybe (Ptr (FunPtr (ListBoxSortFuncC))) ->+    ListBoxSortFunc ->+    Ptr ListBoxRow ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO Int32+listBoxSortFuncWrapper funptrptr _cb row1 row2 _ = do+    row1' <- (newObject ListBoxRow) row1+    row2' <- (newObject ListBoxRow) row2+    result <- _cb  row1' row2'+    maybeReleaseFunPtr funptrptr+    return result++-- callback ListBoxForeachFunc+listBoxForeachFuncClosure :: ListBoxForeachFunc -> IO Closure+listBoxForeachFuncClosure cb = newCClosure =<< mkListBoxForeachFunc wrapped+    where wrapped = listBoxForeachFuncWrapper Nothing cb++type ListBoxForeachFuncC =+    Ptr ListBox ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkListBoxForeachFunc :: ListBoxForeachFuncC -> IO (FunPtr ListBoxForeachFuncC)++type ListBoxForeachFunc =+    ListBox ->+    ListBoxRow ->+    IO ()++noListBoxForeachFunc :: Maybe ListBoxForeachFunc+noListBoxForeachFunc = Nothing++listBoxForeachFuncWrapper ::+    Maybe (Ptr (FunPtr (ListBoxForeachFuncC))) ->+    ListBoxForeachFunc ->+    Ptr ListBox ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()+listBoxForeachFuncWrapper funptrptr _cb box row _ = do+    box' <- (newObject ListBox) box+    row' <- (newObject ListBoxRow) row+    _cb  box' row'+    maybeReleaseFunPtr funptrptr++-- callback ListBoxFilterFunc+listBoxFilterFuncClosure :: ListBoxFilterFunc -> IO Closure+listBoxFilterFuncClosure cb = newCClosure =<< mkListBoxFilterFunc wrapped+    where wrapped = listBoxFilterFuncWrapper Nothing cb++type ListBoxFilterFuncC =+    Ptr ListBoxRow ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkListBoxFilterFunc :: ListBoxFilterFuncC -> IO (FunPtr ListBoxFilterFuncC)++type ListBoxFilterFunc =+    ListBoxRow ->+    IO Bool++noListBoxFilterFunc :: Maybe ListBoxFilterFunc+noListBoxFilterFunc = Nothing++listBoxFilterFuncWrapper ::+    Maybe (Ptr (FunPtr (ListBoxFilterFuncC))) ->+    ListBoxFilterFunc ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO CInt+listBoxFilterFuncWrapper funptrptr _cb row _ = do+    row' <- (newObject ListBoxRow) row+    result <- _cb  row'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback ListBoxCreateWidgetFunc+listBoxCreateWidgetFuncClosure :: ListBoxCreateWidgetFunc -> IO Closure+listBoxCreateWidgetFuncClosure cb = newCClosure =<< mkListBoxCreateWidgetFunc wrapped+    where wrapped = listBoxCreateWidgetFuncWrapper Nothing cb++type ListBoxCreateWidgetFuncC =+    Ptr GObject.Object ->+    Ptr () ->+    IO (Ptr Widget)++foreign import ccall "wrapper"+    mkListBoxCreateWidgetFunc :: ListBoxCreateWidgetFuncC -> IO (FunPtr ListBoxCreateWidgetFuncC)++type ListBoxCreateWidgetFunc =+    GObject.Object ->+    IO Widget++noListBoxCreateWidgetFunc :: Maybe ListBoxCreateWidgetFunc+noListBoxCreateWidgetFunc = Nothing++listBoxCreateWidgetFuncWrapper ::+    Maybe (Ptr (FunPtr (ListBoxCreateWidgetFuncC))) ->+    ListBoxCreateWidgetFunc ->+    Ptr GObject.Object ->+    Ptr () ->+    IO (Ptr Widget)+listBoxCreateWidgetFuncWrapper funptrptr _cb item _ = do+    item' <- (newObject GObject.Object) item+    result <- _cb  item'+    maybeReleaseFunPtr funptrptr+    result' <- refObject result+    return result'++-- callback KeySnoopFunc+keySnoopFuncClosure :: KeySnoopFunc -> IO Closure+keySnoopFuncClosure cb = newCClosure =<< mkKeySnoopFunc wrapped+    where wrapped = keySnoopFuncWrapper Nothing cb++type KeySnoopFuncC =+    Ptr Widget ->+    Ptr Gdk.EventKey ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkKeySnoopFunc :: KeySnoopFuncC -> IO (FunPtr KeySnoopFuncC)++type KeySnoopFunc =+    Widget ->+    Gdk.EventKey ->+    IO Int32++noKeySnoopFunc :: Maybe KeySnoopFunc+noKeySnoopFunc = Nothing++keySnoopFuncWrapper ::+    Maybe (Ptr (FunPtr (KeySnoopFuncC))) ->+    KeySnoopFunc ->+    Ptr Widget ->+    Ptr Gdk.EventKey ->+    Ptr () ->+    IO Int32+keySnoopFuncWrapper funptrptr _cb grab_widget event _ = do+    grab_widget' <- (newObject Widget) grab_widget+    event' <- (newPtr 56 Gdk.EventKey) event+    result <- _cb  grab_widget' event'+    maybeReleaseFunPtr funptrptr+    return result++-- callback IconViewForeachFunc+iconViewForeachFuncClosure :: IconViewForeachFunc -> IO Closure+iconViewForeachFuncClosure cb = newCClosure =<< mkIconViewForeachFunc wrapped+    where wrapped = iconViewForeachFuncWrapper Nothing cb++type IconViewForeachFuncC =+    Ptr IconView ->+    Ptr TreePath ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkIconViewForeachFunc :: IconViewForeachFuncC -> IO (FunPtr IconViewForeachFuncC)++type IconViewForeachFunc =+    IconView ->+    TreePath ->+    IO ()++noIconViewForeachFunc :: Maybe IconViewForeachFunc+noIconViewForeachFunc = Nothing++iconViewForeachFuncWrapper ::+    Maybe (Ptr (FunPtr (IconViewForeachFuncC))) ->+    IconViewForeachFunc ->+    Ptr IconView ->+    Ptr TreePath ->+    Ptr () ->+    IO ()+iconViewForeachFuncWrapper funptrptr _cb icon_view path _ = do+    icon_view' <- (newObject IconView) icon_view+    path' <- (newBoxed TreePath) path+    _cb  icon_view' path'+    maybeReleaseFunPtr funptrptr++-- callback FontFilterFunc+fontFilterFuncClosure :: FontFilterFunc -> IO Closure+fontFilterFuncClosure cb = newCClosure =<< mkFontFilterFunc wrapped+    where wrapped = fontFilterFuncWrapper Nothing cb++type FontFilterFuncC =+    Ptr Pango.FontFamily ->+    Ptr Pango.FontFace ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkFontFilterFunc :: FontFilterFuncC -> IO (FunPtr FontFilterFuncC)++type FontFilterFunc =+    Pango.FontFamily ->+    Pango.FontFace ->+    IO Bool++noFontFilterFunc :: Maybe FontFilterFunc+noFontFilterFunc = Nothing++fontFilterFuncWrapper ::+    Maybe (Ptr (FunPtr (FontFilterFuncC))) ->+    FontFilterFunc ->+    Ptr Pango.FontFamily ->+    Ptr Pango.FontFace ->+    Ptr () ->+    IO CInt+fontFilterFuncWrapper funptrptr _cb family face _ = do+    family' <- (newObject Pango.FontFamily) family+    face' <- (newObject Pango.FontFace) face+    result <- _cb  family' face'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback FlowBoxSortFunc+flowBoxSortFuncClosure :: FlowBoxSortFunc -> IO Closure+flowBoxSortFuncClosure cb = newCClosure =<< mkFlowBoxSortFunc wrapped+    where wrapped = flowBoxSortFuncWrapper Nothing cb++type FlowBoxSortFuncC =+    Ptr FlowBoxChild ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkFlowBoxSortFunc :: FlowBoxSortFuncC -> IO (FunPtr FlowBoxSortFuncC)++type FlowBoxSortFunc =+    FlowBoxChild ->+    FlowBoxChild ->+    IO Int32++noFlowBoxSortFunc :: Maybe FlowBoxSortFunc+noFlowBoxSortFunc = Nothing++flowBoxSortFuncWrapper ::+    Maybe (Ptr (FunPtr (FlowBoxSortFuncC))) ->+    FlowBoxSortFunc ->+    Ptr FlowBoxChild ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO Int32+flowBoxSortFuncWrapper funptrptr _cb child1 child2 _ = do+    child1' <- (newObject FlowBoxChild) child1+    child2' <- (newObject FlowBoxChild) child2+    result <- _cb  child1' child2'+    maybeReleaseFunPtr funptrptr+    return result++-- callback FlowBoxForeachFunc+flowBoxForeachFuncClosure :: FlowBoxForeachFunc -> IO Closure+flowBoxForeachFuncClosure cb = newCClosure =<< mkFlowBoxForeachFunc wrapped+    where wrapped = flowBoxForeachFuncWrapper Nothing cb++type FlowBoxForeachFuncC =+    Ptr FlowBox ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxForeachFunc :: FlowBoxForeachFuncC -> IO (FunPtr FlowBoxForeachFuncC)++type FlowBoxForeachFunc =+    FlowBox ->+    FlowBoxChild ->+    IO ()++noFlowBoxForeachFunc :: Maybe FlowBoxForeachFunc+noFlowBoxForeachFunc = Nothing++flowBoxForeachFuncWrapper ::+    Maybe (Ptr (FunPtr (FlowBoxForeachFuncC))) ->+    FlowBoxForeachFunc ->+    Ptr FlowBox ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO ()+flowBoxForeachFuncWrapper funptrptr _cb box child _ = do+    box' <- (newObject FlowBox) box+    child' <- (newObject FlowBoxChild) child+    _cb  box' child'+    maybeReleaseFunPtr funptrptr++-- callback FlowBoxFilterFunc+flowBoxFilterFuncClosure :: FlowBoxFilterFunc -> IO Closure+flowBoxFilterFuncClosure cb = newCClosure =<< mkFlowBoxFilterFunc wrapped+    where wrapped = flowBoxFilterFuncWrapper Nothing cb++type FlowBoxFilterFuncC =+    Ptr FlowBoxChild ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkFlowBoxFilterFunc :: FlowBoxFilterFuncC -> IO (FunPtr FlowBoxFilterFuncC)++type FlowBoxFilterFunc =+    FlowBoxChild ->+    IO Bool++noFlowBoxFilterFunc :: Maybe FlowBoxFilterFunc+noFlowBoxFilterFunc = Nothing++flowBoxFilterFuncWrapper ::+    Maybe (Ptr (FunPtr (FlowBoxFilterFuncC))) ->+    FlowBoxFilterFunc ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO CInt+flowBoxFilterFuncWrapper funptrptr _cb child _ = do+    child' <- (newObject FlowBoxChild) child+    result <- _cb  child'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback FileFilterFunc+fileFilterFuncClosure :: FileFilterFunc -> IO Closure+fileFilterFuncClosure cb = newCClosure =<< mkFileFilterFunc wrapped+    where wrapped = fileFilterFuncWrapper Nothing cb++type FileFilterFuncC =+    Ptr FileFilterInfo ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkFileFilterFunc :: FileFilterFuncC -> IO (FunPtr FileFilterFuncC)++type FileFilterFunc =+    FileFilterInfo ->+    IO Bool++noFileFilterFunc :: Maybe FileFilterFunc+noFileFilterFunc = Nothing++fileFilterFuncWrapper ::+    Maybe (Ptr (FunPtr (FileFilterFuncC))) ->+    FileFilterFunc ->+    Ptr FileFilterInfo ->+    Ptr () ->+    IO CInt+fileFilterFuncWrapper funptrptr _cb filter_info _ = do+    filter_info' <- (newPtr 40 FileFilterInfo) filter_info+    result <- _cb  filter_info'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback EntryCompletionMatchFunc+entryCompletionMatchFuncClosure :: EntryCompletionMatchFunc -> IO Closure+entryCompletionMatchFuncClosure cb = newCClosure =<< mkEntryCompletionMatchFunc wrapped+    where wrapped = entryCompletionMatchFuncWrapper Nothing cb++type EntryCompletionMatchFuncC =+    Ptr EntryCompletion ->+    CString ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkEntryCompletionMatchFunc :: EntryCompletionMatchFuncC -> IO (FunPtr EntryCompletionMatchFuncC)++type EntryCompletionMatchFunc =+    EntryCompletion ->+    T.Text ->+    TreeIter ->+    IO Bool++noEntryCompletionMatchFunc :: Maybe EntryCompletionMatchFunc+noEntryCompletionMatchFunc = Nothing++entryCompletionMatchFuncWrapper ::+    Maybe (Ptr (FunPtr (EntryCompletionMatchFuncC))) ->+    EntryCompletionMatchFunc ->+    Ptr EntryCompletion ->+    CString ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+entryCompletionMatchFuncWrapper funptrptr _cb completion key iter _ = do+    completion' <- (newObject EntryCompletion) completion+    key' <- cstringToText key+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  completion' key' iter'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback ColorSelectionChangePaletteWithScreenFunc+colorSelectionChangePaletteWithScreenFuncClosure :: ColorSelectionChangePaletteWithScreenFunc -> IO Closure+colorSelectionChangePaletteWithScreenFuncClosure cb = newCClosure =<< mkColorSelectionChangePaletteWithScreenFunc wrapped+    where wrapped = colorSelectionChangePaletteWithScreenFuncWrapper Nothing cb++type ColorSelectionChangePaletteWithScreenFuncC =+    Ptr Gdk.Screen ->+    Ptr Gdk.Color ->+    Int32 ->+    IO ()++foreign import ccall "wrapper"+    mkColorSelectionChangePaletteWithScreenFunc :: ColorSelectionChangePaletteWithScreenFuncC -> IO (FunPtr ColorSelectionChangePaletteWithScreenFuncC)++type ColorSelectionChangePaletteWithScreenFunc =+    Gdk.Screen ->+    [Gdk.Color] ->+    IO ()++noColorSelectionChangePaletteWithScreenFunc :: Maybe ColorSelectionChangePaletteWithScreenFunc+noColorSelectionChangePaletteWithScreenFunc = Nothing++colorSelectionChangePaletteWithScreenFuncWrapper ::+    Maybe (Ptr (FunPtr (ColorSelectionChangePaletteWithScreenFuncC))) ->+    ColorSelectionChangePaletteWithScreenFunc ->+    Ptr Gdk.Screen ->+    Ptr Gdk.Color ->+    Int32 ->+    IO ()+colorSelectionChangePaletteWithScreenFuncWrapper funptrptr _cb screen colors n_colors = do+    screen' <- (newObject Gdk.Screen) screen+    colors' <- (unpackBoxedArrayWithLength 12 n_colors) colors+    colors'' <- mapM (newBoxed Gdk.Color) colors'+    _cb  screen' colors''+    maybeReleaseFunPtr funptrptr++-- callback ColorSelectionChangePaletteFunc+colorSelectionChangePaletteFuncClosure :: ColorSelectionChangePaletteFunc -> IO Closure+colorSelectionChangePaletteFuncClosure cb = newCClosure =<< mkColorSelectionChangePaletteFunc wrapped+    where wrapped = colorSelectionChangePaletteFuncWrapper Nothing cb++type ColorSelectionChangePaletteFuncC =+    Ptr Gdk.Color ->+    Int32 ->+    IO ()++foreign import ccall "wrapper"+    mkColorSelectionChangePaletteFunc :: ColorSelectionChangePaletteFuncC -> IO (FunPtr ColorSelectionChangePaletteFuncC)++type ColorSelectionChangePaletteFunc =+    [Gdk.Color] ->+    IO ()++noColorSelectionChangePaletteFunc :: Maybe ColorSelectionChangePaletteFunc+noColorSelectionChangePaletteFunc = Nothing++colorSelectionChangePaletteFuncWrapper ::+    Maybe (Ptr (FunPtr (ColorSelectionChangePaletteFuncC))) ->+    ColorSelectionChangePaletteFunc ->+    Ptr Gdk.Color ->+    Int32 ->+    IO ()+colorSelectionChangePaletteFuncWrapper funptrptr _cb colors n_colors = do+    colors' <- (unpackBoxedArrayWithLength 12 n_colors) colors+    colors'' <- mapM (newBoxed Gdk.Color) colors'+    _cb  colors''+    maybeReleaseFunPtr funptrptr++-- callback ClipboardURIReceivedFunc+clipboardURIReceivedFuncClosure :: ClipboardURIReceivedFunc -> IO Closure+clipboardURIReceivedFuncClosure cb = newCClosure =<< mkClipboardURIReceivedFunc wrapped+    where wrapped = clipboardURIReceivedFuncWrapper Nothing cb++type ClipboardURIReceivedFuncC =+    Ptr Clipboard ->+    Ptr CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardURIReceivedFunc :: ClipboardURIReceivedFuncC -> IO (FunPtr ClipboardURIReceivedFuncC)++type ClipboardURIReceivedFunc =+    Clipboard ->+    [T.Text] ->+    IO ()++noClipboardURIReceivedFunc :: Maybe ClipboardURIReceivedFunc+noClipboardURIReceivedFunc = Nothing++clipboardURIReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardURIReceivedFuncC))) ->+    ClipboardURIReceivedFunc ->+    Ptr Clipboard ->+    Ptr CString ->+    Ptr () ->+    IO ()+clipboardURIReceivedFuncWrapper funptrptr _cb clipboard uris _ = do+    clipboard' <- (newObject Clipboard) clipboard+    uris' <- unpackZeroTerminatedUTF8CArray uris+    _cb  clipboard' uris'+    maybeReleaseFunPtr funptrptr++-- callback ClipboardTextReceivedFunc+clipboardTextReceivedFuncClosure :: ClipboardTextReceivedFunc -> IO Closure+clipboardTextReceivedFuncClosure cb = newCClosure =<< mkClipboardTextReceivedFunc wrapped+    where wrapped = clipboardTextReceivedFuncWrapper Nothing cb++type ClipboardTextReceivedFuncC =+    Ptr Clipboard ->+    CString ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardTextReceivedFunc :: ClipboardTextReceivedFuncC -> IO (FunPtr ClipboardTextReceivedFuncC)++type ClipboardTextReceivedFunc =+    Clipboard ->+    Maybe T.Text ->+    IO ()++noClipboardTextReceivedFunc :: Maybe ClipboardTextReceivedFunc+noClipboardTextReceivedFunc = Nothing++clipboardTextReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardTextReceivedFuncC))) ->+    ClipboardTextReceivedFunc ->+    Ptr Clipboard ->+    CString ->+    Ptr () ->+    IO ()+clipboardTextReceivedFuncWrapper funptrptr _cb clipboard text _ = do+    clipboard' <- (newObject Clipboard) clipboard+    maybeText <-+        if text == nullPtr+        then return Nothing+        else do+            text' <- cstringToText text+            return $ Just text'+    _cb  clipboard' maybeText+    maybeReleaseFunPtr funptrptr++-- callback ClipboardTargetsReceivedFunc+clipboardTargetsReceivedFuncClosure :: ClipboardTargetsReceivedFunc -> IO Closure+clipboardTargetsReceivedFuncClosure cb = newCClosure =<< mkClipboardTargetsReceivedFunc wrapped+    where wrapped = clipboardTargetsReceivedFuncWrapper Nothing cb++type ClipboardTargetsReceivedFuncC =+    Ptr Clipboard ->+    Ptr (Ptr Gdk.Atom) ->+    Int32 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardTargetsReceivedFunc :: ClipboardTargetsReceivedFuncC -> IO (FunPtr ClipboardTargetsReceivedFuncC)++type ClipboardTargetsReceivedFunc =+    Clipboard ->+    Maybe [Gdk.Atom] ->+    IO ()++noClipboardTargetsReceivedFunc :: Maybe ClipboardTargetsReceivedFunc+noClipboardTargetsReceivedFunc = Nothing++clipboardTargetsReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardTargetsReceivedFuncC))) ->+    ClipboardTargetsReceivedFunc ->+    Ptr Clipboard ->+    Ptr (Ptr Gdk.Atom) ->+    Int32 ->+    Ptr () ->+    IO ()+clipboardTargetsReceivedFuncWrapper funptrptr _cb clipboard atoms n_atoms _ = do+    clipboard' <- (newObject Clipboard) clipboard+    maybeAtoms <-+        if atoms == nullPtr+        then return Nothing+        else do+            -- XXX Wrapping a foreign struct/union with no known destructor, leak?+            atoms' <- (unpackPtrArrayWithLength n_atoms) atoms+            atoms'' <- mapM (\x -> Gdk.Atom <$> newForeignPtr_ x) atoms'+            return $ Just atoms''+    _cb  clipboard' maybeAtoms+    maybeReleaseFunPtr funptrptr++-- callback ClipboardRichTextReceivedFunc+clipboardRichTextReceivedFuncClosure :: ClipboardRichTextReceivedFunc -> IO Closure+clipboardRichTextReceivedFuncClosure cb = newCClosure =<< mkClipboardRichTextReceivedFunc wrapped+    where wrapped = clipboardRichTextReceivedFuncWrapper Nothing cb++type ClipboardRichTextReceivedFuncC =+    Ptr Clipboard ->+    Ptr Gdk.Atom ->+    CString ->+    Word64 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardRichTextReceivedFunc :: ClipboardRichTextReceivedFuncC -> IO (FunPtr ClipboardRichTextReceivedFuncC)++type ClipboardRichTextReceivedFunc =+    Clipboard ->+    Gdk.Atom ->+    Maybe T.Text ->+    Word64 ->+    IO ()++noClipboardRichTextReceivedFunc :: Maybe ClipboardRichTextReceivedFunc+noClipboardRichTextReceivedFunc = Nothing++clipboardRichTextReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardRichTextReceivedFuncC))) ->+    ClipboardRichTextReceivedFunc ->+    Ptr Clipboard ->+    Ptr Gdk.Atom ->+    CString ->+    Word64 ->+    Ptr () ->+    IO ()+clipboardRichTextReceivedFuncWrapper funptrptr _cb clipboard format text length_ _ = do+    clipboard' <- (newObject Clipboard) clipboard+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    format' <- (\x -> Gdk.Atom <$> newForeignPtr_ x) format+    maybeText <-+        if text == nullPtr+        then return Nothing+        else do+            text' <- cstringToText text+            return $ Just text'+    _cb  clipboard' format' maybeText length_+    maybeReleaseFunPtr funptrptr++-- callback ClipboardReceivedFunc+clipboardReceivedFuncClosure :: ClipboardReceivedFunc -> IO Closure+clipboardReceivedFuncClosure cb = newCClosure =<< mkClipboardReceivedFunc wrapped+    where wrapped = clipboardReceivedFuncWrapper Nothing cb++type ClipboardReceivedFuncC =+    Ptr Clipboard ->+    Ptr SelectionData ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardReceivedFunc :: ClipboardReceivedFuncC -> IO (FunPtr ClipboardReceivedFuncC)++type ClipboardReceivedFunc =+    Clipboard ->+    SelectionData ->+    IO ()++noClipboardReceivedFunc :: Maybe ClipboardReceivedFunc+noClipboardReceivedFunc = Nothing++clipboardReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardReceivedFuncC))) ->+    ClipboardReceivedFunc ->+    Ptr Clipboard ->+    Ptr SelectionData ->+    Ptr () ->+    IO ()+clipboardReceivedFuncWrapper funptrptr _cb clipboard selection_data _ = do+    clipboard' <- (newObject Clipboard) clipboard+    selection_data' <- (newBoxed SelectionData) selection_data+    _cb  clipboard' selection_data'+    maybeReleaseFunPtr funptrptr++-- callback ClipboardImageReceivedFunc+clipboardImageReceivedFuncClosure :: ClipboardImageReceivedFunc -> IO Closure+clipboardImageReceivedFuncClosure cb = newCClosure =<< mkClipboardImageReceivedFunc wrapped+    where wrapped = clipboardImageReceivedFuncWrapper Nothing cb++type ClipboardImageReceivedFuncC =+    Ptr Clipboard ->+    Ptr GdkPixbuf.Pixbuf ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardImageReceivedFunc :: ClipboardImageReceivedFuncC -> IO (FunPtr ClipboardImageReceivedFuncC)++type ClipboardImageReceivedFunc =+    Clipboard ->+    GdkPixbuf.Pixbuf ->+    IO ()++noClipboardImageReceivedFunc :: Maybe ClipboardImageReceivedFunc+noClipboardImageReceivedFunc = Nothing++clipboardImageReceivedFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardImageReceivedFuncC))) ->+    ClipboardImageReceivedFunc ->+    Ptr Clipboard ->+    Ptr GdkPixbuf.Pixbuf ->+    Ptr () ->+    IO ()+clipboardImageReceivedFuncWrapper funptrptr _cb clipboard pixbuf _ = do+    clipboard' <- (newObject Clipboard) clipboard+    pixbuf' <- (newObject GdkPixbuf.Pixbuf) pixbuf+    _cb  clipboard' pixbuf'+    maybeReleaseFunPtr funptrptr++-- callback ClipboardGetFunc+clipboardGetFuncClosure :: ClipboardGetFunc -> IO Closure+clipboardGetFuncClosure cb = newCClosure =<< mkClipboardGetFunc wrapped+    where wrapped = clipboardGetFuncWrapper Nothing cb++type ClipboardGetFuncC =+    Ptr Clipboard ->+    Ptr SelectionData ->+    Word32 ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardGetFunc :: ClipboardGetFuncC -> IO (FunPtr ClipboardGetFuncC)++type ClipboardGetFunc =+    Clipboard ->+    SelectionData ->+    Word32 ->+    Ptr () ->+    IO ()++noClipboardGetFunc :: Maybe ClipboardGetFunc+noClipboardGetFunc = Nothing++clipboardGetFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardGetFuncC))) ->+    ClipboardGetFunc ->+    Ptr Clipboard ->+    Ptr SelectionData ->+    Word32 ->+    Ptr () ->+    IO ()+clipboardGetFuncWrapper funptrptr _cb clipboard selection_data info user_data_or_owner = do+    clipboard' <- (newObject Clipboard) clipboard+    selection_data' <- (newBoxed SelectionData) selection_data+    _cb  clipboard' selection_data' info user_data_or_owner+    maybeReleaseFunPtr funptrptr++-- callback ClipboardClearFunc+clipboardClearFuncClosure :: ClipboardClearFunc -> IO Closure+clipboardClearFuncClosure cb = newCClosure =<< mkClipboardClearFunc wrapped+    where wrapped = clipboardClearFuncWrapper Nothing cb++type ClipboardClearFuncC =+    Ptr Clipboard ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkClipboardClearFunc :: ClipboardClearFuncC -> IO (FunPtr ClipboardClearFuncC)++type ClipboardClearFunc =+    Clipboard ->+    Ptr () ->+    IO ()++noClipboardClearFunc :: Maybe ClipboardClearFunc+noClipboardClearFunc = Nothing++clipboardClearFuncWrapper ::+    Maybe (Ptr (FunPtr (ClipboardClearFuncC))) ->+    ClipboardClearFunc ->+    Ptr Clipboard ->+    Ptr () ->+    IO ()+clipboardClearFuncWrapper funptrptr _cb clipboard user_data_or_owner = do+    clipboard' <- (newObject Clipboard) clipboard+    _cb  clipboard' user_data_or_owner+    maybeReleaseFunPtr funptrptr++-- callback CellLayoutDataFunc+cellLayoutDataFuncClosure :: CellLayoutDataFunc -> IO Closure+cellLayoutDataFuncClosure cb = newCClosure =<< mkCellLayoutDataFunc wrapped+    where wrapped = cellLayoutDataFuncWrapper Nothing cb++type CellLayoutDataFuncC =+    Ptr CellLayout ->+    Ptr CellRenderer ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkCellLayoutDataFunc :: CellLayoutDataFuncC -> IO (FunPtr CellLayoutDataFuncC)++type CellLayoutDataFunc =+    CellLayout ->+    CellRenderer ->+    TreeModel ->+    TreeIter ->+    IO ()++noCellLayoutDataFunc :: Maybe CellLayoutDataFunc+noCellLayoutDataFunc = Nothing++cellLayoutDataFuncWrapper ::+    Maybe (Ptr (FunPtr (CellLayoutDataFuncC))) ->+    CellLayoutDataFunc ->+    Ptr CellLayout ->+    Ptr CellRenderer ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+cellLayoutDataFuncWrapper funptrptr _cb cell_layout cell tree_model iter _ = do+    cell_layout' <- (newObject CellLayout) cell_layout+    cell' <- (newObject CellRenderer) cell+    tree_model' <- (newObject TreeModel) tree_model+    iter' <- (newBoxed TreeIter) iter+    _cb  cell_layout' cell' tree_model' iter'+    maybeReleaseFunPtr funptrptr++-- callback CellCallback+cellCallbackClosure :: CellCallback -> IO Closure+cellCallbackClosure cb = newCClosure =<< mkCellCallback wrapped+    where wrapped = cellCallbackWrapper Nothing cb++type CellCallbackC =+    Ptr CellRenderer ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkCellCallback :: CellCallbackC -> IO (FunPtr CellCallbackC)++type CellCallback =+    CellRenderer ->+    IO Bool++noCellCallback :: Maybe CellCallback+noCellCallback = Nothing++cellCallbackWrapper ::+    Maybe (Ptr (FunPtr (CellCallbackC))) ->+    CellCallback ->+    Ptr CellRenderer ->+    Ptr () ->+    IO CInt+cellCallbackWrapper funptrptr _cb renderer _ = do+    renderer' <- (newObject CellRenderer) renderer+    result <- _cb  renderer'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback CellAllocCallback+cellAllocCallbackClosure :: CellAllocCallback -> IO Closure+cellAllocCallbackClosure cb = newCClosure =<< mkCellAllocCallback wrapped+    where wrapped = cellAllocCallbackWrapper Nothing cb++type CellAllocCallbackC =+    Ptr CellRenderer ->+    Ptr Gdk.Rectangle ->+    Ptr Gdk.Rectangle ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkCellAllocCallback :: CellAllocCallbackC -> IO (FunPtr CellAllocCallbackC)++type CellAllocCallback =+    CellRenderer ->+    Gdk.Rectangle ->+    Gdk.Rectangle ->+    IO Bool++noCellAllocCallback :: Maybe CellAllocCallback+noCellAllocCallback = Nothing++cellAllocCallbackWrapper ::+    Maybe (Ptr (FunPtr (CellAllocCallbackC))) ->+    CellAllocCallback ->+    Ptr CellRenderer ->+    Ptr Gdk.Rectangle ->+    Ptr Gdk.Rectangle ->+    Ptr () ->+    IO CInt+cellAllocCallbackWrapper funptrptr _cb renderer cell_area cell_background _ = do+    renderer' <- (newObject CellRenderer) renderer+    cell_area' <- (newBoxed Gdk.Rectangle) cell_area+    cell_background' <- (newBoxed Gdk.Rectangle) cell_background+    result <- _cb  renderer' cell_area' cell_background'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback Callback+callbackClosure :: Callback -> IO Closure+callbackClosure cb = newCClosure =<< mkCallback wrapped+    where wrapped = callbackWrapper Nothing cb++type CallbackC =+    Ptr Widget ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkCallback :: CallbackC -> IO (FunPtr CallbackC)++type Callback =+    Widget ->+    IO ()++noCallback :: Maybe Callback+noCallback = Nothing++callbackWrapper ::+    Maybe (Ptr (FunPtr (CallbackC))) ->+    Callback ->+    Ptr Widget ->+    Ptr () ->+    IO ()+callbackWrapper funptrptr _cb widget _ = do+    widget' <- (newObject Widget) widget+    _cb  widget'+    maybeReleaseFunPtr funptrptr++-- callback CalendarDetailFunc+calendarDetailFuncClosure :: CalendarDetailFunc -> IO Closure+calendarDetailFuncClosure cb = newCClosure =<< mkCalendarDetailFunc wrapped+    where wrapped = calendarDetailFuncWrapper Nothing cb++type CalendarDetailFuncC =+    Ptr Calendar ->+    Word32 ->+    Word32 ->+    Word32 ->+    Ptr () ->+    IO CString++foreign import ccall "wrapper"+    mkCalendarDetailFunc :: CalendarDetailFuncC -> IO (FunPtr CalendarDetailFuncC)++type CalendarDetailFunc =+    Calendar ->+    Word32 ->+    Word32 ->+    Word32 ->+    IO T.Text++noCalendarDetailFunc :: Maybe CalendarDetailFunc+noCalendarDetailFunc = Nothing++calendarDetailFuncWrapper ::+    Maybe (Ptr (FunPtr (CalendarDetailFuncC))) ->+    CalendarDetailFunc ->+    Ptr Calendar ->+    Word32 ->+    Word32 ->+    Word32 ->+    Ptr () ->+    IO CString+calendarDetailFuncWrapper funptrptr _cb calendar year month day _ = do+    calendar' <- (newObject Calendar) calendar+    result <- _cb  calendar' year month day+    maybeReleaseFunPtr funptrptr+    result' <- textToCString result+    return result'++-- callback BuilderConnectFunc+builderConnectFuncClosure :: BuilderConnectFunc -> IO Closure+builderConnectFuncClosure cb = newCClosure =<< mkBuilderConnectFunc wrapped+    where wrapped = builderConnectFuncWrapper Nothing cb++type BuilderConnectFuncC =+    Ptr Builder ->+    Ptr GObject.Object ->+    CString ->+    CString ->+    Ptr GObject.Object ->+    CUInt ->+    Ptr () ->+    IO ()++foreign import ccall "wrapper"+    mkBuilderConnectFunc :: BuilderConnectFuncC -> IO (FunPtr BuilderConnectFuncC)++type BuilderConnectFunc =+    Builder ->+    GObject.Object ->+    T.Text ->+    T.Text ->+    Maybe GObject.Object ->+    [GObject.ConnectFlags] ->+    IO ()++noBuilderConnectFunc :: Maybe BuilderConnectFunc+noBuilderConnectFunc = Nothing++builderConnectFuncWrapper ::+    Maybe (Ptr (FunPtr (BuilderConnectFuncC))) ->+    BuilderConnectFunc ->+    Ptr Builder ->+    Ptr GObject.Object ->+    CString ->+    CString ->+    Ptr GObject.Object ->+    CUInt ->+    Ptr () ->+    IO ()+builderConnectFuncWrapper funptrptr _cb builder object signal_name handler_name connect_object flags _ = do+    builder' <- (newObject Builder) builder+    object' <- (newObject GObject.Object) object+    signal_name' <- cstringToText signal_name+    handler_name' <- cstringToText handler_name+    maybeConnect_object <-+        if connect_object == nullPtr+        then return Nothing+        else do+            connect_object' <- (newObject GObject.Object) connect_object+            return $ Just connect_object'+    let flags' = wordToGFlags flags+    _cb  builder' object' signal_name' handler_name' maybeConnect_object flags'+    maybeReleaseFunPtr funptrptr++-- callback AssistantPageFunc+assistantPageFuncClosure :: AssistantPageFunc -> IO Closure+assistantPageFuncClosure cb = newCClosure =<< mkAssistantPageFunc wrapped+    where wrapped = assistantPageFuncWrapper Nothing cb++type AssistantPageFuncC =+    Int32 ->+    Ptr () ->+    IO Int32++foreign import ccall "wrapper"+    mkAssistantPageFunc :: AssistantPageFuncC -> IO (FunPtr AssistantPageFuncC)++type AssistantPageFunc =+    Int32 ->+    IO Int32++noAssistantPageFunc :: Maybe AssistantPageFunc+noAssistantPageFunc = Nothing++assistantPageFuncWrapper ::+    Maybe (Ptr (FunPtr (AssistantPageFuncC))) ->+    AssistantPageFunc ->+    Int32 ->+    Ptr () ->+    IO Int32+assistantPageFuncWrapper funptrptr _cb current_page _ = do+    result <- _cb  current_page+    maybeReleaseFunPtr funptrptr+    return result++-- callback AccelMapForeach+accelMapForeachClosure :: AccelMapForeach -> IO Closure+accelMapForeachClosure cb = newCClosure =<< mkAccelMapForeach wrapped+    where wrapped = accelMapForeachWrapper Nothing cb++type AccelMapForeachC =+    Ptr () ->+    CString ->+    Word32 ->+    CUInt ->+    CInt ->+    IO ()++foreign import ccall "wrapper"+    mkAccelMapForeach :: AccelMapForeachC -> IO (FunPtr AccelMapForeachC)++type AccelMapForeach =+    Ptr () ->+    T.Text ->+    Word32 ->+    [Gdk.ModifierType] ->+    Bool ->+    IO ()++noAccelMapForeach :: Maybe AccelMapForeach+noAccelMapForeach = Nothing++accelMapForeachWrapper ::+    Maybe (Ptr (FunPtr (AccelMapForeachC))) ->+    AccelMapForeach ->+    Ptr () ->+    CString ->+    Word32 ->+    CUInt ->+    CInt ->+    IO ()+accelMapForeachWrapper funptrptr _cb data_ accel_path accel_key accel_mods changed = do+    accel_path' <- cstringToText accel_path+    let accel_mods' = wordToGFlags accel_mods+    let changed' = (/= 0) changed+    _cb  data_ accel_path' accel_key accel_mods' changed'+    maybeReleaseFunPtr funptrptr++-- callback AccelGroupFindFunc+accelGroupFindFuncClosure :: AccelGroupFindFunc -> IO Closure+accelGroupFindFuncClosure cb = newCClosure =<< mkAccelGroupFindFunc wrapped+    where wrapped = accelGroupFindFuncWrapper Nothing cb++type AccelGroupFindFuncC =+    Ptr AccelKey ->+    Ptr Closure ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkAccelGroupFindFunc :: AccelGroupFindFuncC -> IO (FunPtr AccelGroupFindFuncC)++type AccelGroupFindFunc =+    AccelKey ->+    Closure ->+    IO Bool++noAccelGroupFindFunc :: Maybe AccelGroupFindFunc+noAccelGroupFindFunc = Nothing++accelGroupFindFuncWrapper ::+    Maybe (Ptr (FunPtr (AccelGroupFindFuncC))) ->+    AccelGroupFindFunc ->+    Ptr AccelKey ->+    Ptr Closure ->+    Ptr () ->+    IO CInt+accelGroupFindFuncWrapper funptrptr _cb key closure _ = do+    key' <- (newPtr 12 AccelKey) key+    closure' <- (newBoxed Closure) closure+    result <- _cb  key' closure'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback AccelGroupActivate+accelGroupActivateClosure :: AccelGroupActivate -> IO Closure+accelGroupActivateClosure cb = newCClosure =<< mkAccelGroupActivate wrapped+    where wrapped = accelGroupActivateWrapper Nothing cb++type AccelGroupActivateC =+    Ptr AccelGroup ->+    Ptr GObject.Object ->+    Word32 ->+    CUInt ->+    IO CInt++foreign import ccall "wrapper"+    mkAccelGroupActivate :: AccelGroupActivateC -> IO (FunPtr AccelGroupActivateC)++type AccelGroupActivate =+    AccelGroup ->+    GObject.Object ->+    Word32 ->+    [Gdk.ModifierType] ->+    IO Bool++noAccelGroupActivate :: Maybe AccelGroupActivate+noAccelGroupActivate = Nothing++accelGroupActivateWrapper ::+    Maybe (Ptr (FunPtr (AccelGroupActivateC))) ->+    AccelGroupActivate ->+    Ptr AccelGroup ->+    Ptr GObject.Object ->+    Word32 ->+    CUInt ->+    IO CInt+accelGroupActivateWrapper funptrptr _cb accel_group acceleratable keyval modifier = do+    accel_group' <- (newObject AccelGroup) accel_group+    acceleratable' <- (newObject GObject.Object) acceleratable+    let modifier' = wordToGFlags modifier+    result <- _cb  accel_group' acceleratable' keyval modifier'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++
+ GI/Gtk/Constants.hs view
@@ -0,0 +1,1068 @@+{-# 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.Gtk.Constants+    ( +    pattern TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,+    pattern TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,+    pattern TEXT_VIEW_PRIORITY_VALIDATE     ,+    pattern STYLE_REGION_TAB                ,+    pattern STYLE_REGION_ROW                ,+    pattern STYLE_REGION_COLUMN_HEADER      ,+    pattern STYLE_REGION_COLUMN             ,+    pattern STYLE_PROVIDER_PRIORITY_USER    ,+    pattern STYLE_PROVIDER_PRIORITY_THEME   ,+    pattern STYLE_PROVIDER_PRIORITY_SETTINGS,+    pattern STYLE_PROVIDER_PRIORITY_FALLBACK,+    pattern STYLE_PROVIDER_PRIORITY_APPLICATION,+    pattern STYLE_PROPERTY_PADDING          ,+    pattern STYLE_PROPERTY_MARGIN           ,+    pattern STYLE_PROPERTY_FONT             ,+    pattern STYLE_PROPERTY_COLOR            ,+    pattern STYLE_PROPERTY_BORDER_WIDTH     ,+    pattern STYLE_PROPERTY_BORDER_STYLE     ,+    pattern STYLE_PROPERTY_BORDER_RADIUS    ,+    pattern STYLE_PROPERTY_BORDER_COLOR     ,+    pattern STYLE_PROPERTY_BACKGROUND_IMAGE ,+    pattern STYLE_PROPERTY_BACKGROUND_COLOR ,+    pattern STYLE_CLASS_WIDE                ,+    pattern STYLE_CLASS_WARNING             ,+    pattern STYLE_CLASS_VIEW                ,+    pattern STYLE_CLASS_VERTICAL            ,+    pattern STYLE_CLASS_UNDERSHOOT          ,+    pattern STYLE_CLASS_TROUGH              ,+    pattern STYLE_CLASS_TOUCH_SELECTION     ,+    pattern STYLE_CLASS_TOP                 ,+    pattern STYLE_CLASS_TOOLTIP             ,+    pattern STYLE_CLASS_TOOLBAR             ,+    pattern STYLE_CLASS_TITLEBAR            ,+    pattern STYLE_CLASS_TITLE               ,+    pattern STYLE_CLASS_SUGGESTED_ACTION    ,+    pattern STYLE_CLASS_SUBTITLE            ,+    pattern STYLE_CLASS_STATUSBAR           ,+    pattern STYLE_CLASS_SPINNER             ,+    pattern STYLE_CLASS_SPINBUTTON          ,+    pattern STYLE_CLASS_SLIDER              ,+    pattern STYLE_CLASS_SIDEBAR             ,+    pattern STYLE_CLASS_SEPARATOR           ,+    pattern STYLE_CLASS_SCROLLBARS_JUNCTION ,+    pattern STYLE_CLASS_SCROLLBAR           ,+    pattern STYLE_CLASS_SCALE_HAS_MARKS_BELOW,+    pattern STYLE_CLASS_SCALE_HAS_MARKS_ABOVE,+    pattern STYLE_CLASS_SCALE               ,+    pattern STYLE_CLASS_RUBBERBAND          ,+    pattern STYLE_CLASS_RIGHT               ,+    pattern STYLE_CLASS_READ_ONLY           ,+    pattern STYLE_CLASS_RAISED              ,+    pattern STYLE_CLASS_RADIO               ,+    pattern STYLE_CLASS_QUESTION            ,+    pattern STYLE_CLASS_PULSE               ,+    pattern STYLE_CLASS_PROGRESSBAR         ,+    pattern STYLE_CLASS_PRIMARY_TOOLBAR     ,+    pattern STYLE_CLASS_POPUP               ,+    pattern STYLE_CLASS_POPOVER             ,+    pattern STYLE_CLASS_PAPER               ,+    pattern STYLE_CLASS_PANE_SEPARATOR      ,+    pattern STYLE_CLASS_OVERSHOOT           ,+    pattern STYLE_CLASS_OSD                 ,+    pattern STYLE_CLASS_NOTEBOOK            ,+    pattern STYLE_CLASS_NEEDS_ATTENTION     ,+    pattern STYLE_CLASS_MONOSPACE           ,+    pattern STYLE_CLASS_MESSAGE_DIALOG      ,+    pattern STYLE_CLASS_MENUITEM            ,+    pattern STYLE_CLASS_MENUBAR             ,+    pattern STYLE_CLASS_MENU                ,+    pattern STYLE_CLASS_MARK                ,+    pattern STYLE_CLASS_LIST_ROW            ,+    pattern STYLE_CLASS_LIST                ,+    pattern STYLE_CLASS_LINKED              ,+    pattern STYLE_CLASS_LEVEL_BAR           ,+    pattern STYLE_CLASS_LEFT                ,+    pattern STYLE_CLASS_LABEL               ,+    pattern STYLE_CLASS_INSERTION_CURSOR    ,+    pattern STYLE_CLASS_INLINE_TOOLBAR      ,+    pattern STYLE_CLASS_INFO                ,+    pattern STYLE_CLASS_IMAGE               ,+    pattern STYLE_CLASS_HORIZONTAL          ,+    pattern STYLE_CLASS_HIGHLIGHT           ,+    pattern STYLE_CLASS_HEADER              ,+    pattern STYLE_CLASS_GRIP                ,+    pattern STYLE_CLASS_FRAME               ,+    pattern STYLE_CLASS_FLAT                ,+    pattern STYLE_CLASS_EXPANDER            ,+    pattern STYLE_CLASS_ERROR               ,+    pattern STYLE_CLASS_ENTRY               ,+    pattern STYLE_CLASS_DOCK                ,+    pattern STYLE_CLASS_DND                 ,+    pattern STYLE_CLASS_DIM_LABEL           ,+    pattern STYLE_CLASS_DESTRUCTIVE_ACTION  ,+    pattern STYLE_CLASS_DEFAULT             ,+    pattern STYLE_CLASS_CURSOR_HANDLE       ,+    pattern STYLE_CLASS_CSD                 ,+    pattern STYLE_CLASS_CONTEXT_MENU        ,+    pattern STYLE_CLASS_COMBOBOX_ENTRY      ,+    pattern STYLE_CLASS_CHECK               ,+    pattern STYLE_CLASS_CELL                ,+    pattern STYLE_CLASS_CALENDAR            ,+    pattern STYLE_CLASS_BUTTON              ,+    pattern STYLE_CLASS_BOTTOM              ,+    pattern STYLE_CLASS_BACKGROUND          ,+    pattern STYLE_CLASS_ARROW               ,+    pattern STYLE_CLASS_ACCELERATOR         ,+    pattern STOCK_ZOOM_OUT                  ,+    pattern STOCK_ZOOM_IN                   ,+    pattern STOCK_ZOOM_FIT                  ,+    pattern STOCK_ZOOM_100                  ,+    pattern STOCK_YES                       ,+    pattern STOCK_UNINDENT                  ,+    pattern STOCK_UNDO                      ,+    pattern STOCK_UNDERLINE                 ,+    pattern STOCK_UNDELETE                  ,+    pattern STOCK_STRIKETHROUGH             ,+    pattern STOCK_STOP                      ,+    pattern STOCK_SPELL_CHECK               ,+    pattern STOCK_SORT_DESCENDING           ,+    pattern STOCK_SORT_ASCENDING            ,+    pattern STOCK_SELECT_FONT               ,+    pattern STOCK_SELECT_COLOR              ,+    pattern STOCK_SELECT_ALL                ,+    pattern STOCK_SAVE_AS                   ,+    pattern STOCK_SAVE                      ,+    pattern STOCK_REVERT_TO_SAVED           ,+    pattern STOCK_REMOVE                    ,+    pattern STOCK_REFRESH                   ,+    pattern STOCK_REDO                      ,+    pattern STOCK_QUIT                      ,+    pattern STOCK_PROPERTIES                ,+    pattern STOCK_PRINT_WARNING             ,+    pattern STOCK_PRINT_REPORT              ,+    pattern STOCK_PRINT_PREVIEW             ,+    pattern STOCK_PRINT_PAUSED              ,+    pattern STOCK_PRINT_ERROR               ,+    pattern STOCK_PRINT                     ,+    pattern STOCK_PREFERENCES               ,+    pattern STOCK_PASTE                     ,+    pattern STOCK_PAGE_SETUP                ,+    pattern STOCK_ORIENTATION_REVERSE_PORTRAIT,+    pattern STOCK_ORIENTATION_REVERSE_LANDSCAPE,+    pattern STOCK_ORIENTATION_PORTRAIT      ,+    pattern STOCK_ORIENTATION_LANDSCAPE     ,+    pattern STOCK_OPEN                      ,+    pattern STOCK_OK                        ,+    pattern STOCK_NO                        ,+    pattern STOCK_NEW                       ,+    pattern STOCK_NETWORK                   ,+    pattern STOCK_MISSING_IMAGE             ,+    pattern STOCK_MEDIA_STOP                ,+    pattern STOCK_MEDIA_REWIND              ,+    pattern STOCK_MEDIA_RECORD              ,+    pattern STOCK_MEDIA_PREVIOUS            ,+    pattern STOCK_MEDIA_PLAY                ,+    pattern STOCK_MEDIA_PAUSE               ,+    pattern STOCK_MEDIA_NEXT                ,+    pattern STOCK_MEDIA_FORWARD             ,+    pattern STOCK_LEAVE_FULLSCREEN          ,+    pattern STOCK_JUSTIFY_RIGHT             ,+    pattern STOCK_JUSTIFY_LEFT              ,+    pattern STOCK_JUSTIFY_FILL              ,+    pattern STOCK_JUSTIFY_CENTER            ,+    pattern STOCK_JUMP_TO                   ,+    pattern STOCK_ITALIC                    ,+    pattern STOCK_INFO                      ,+    pattern STOCK_INDEX                     ,+    pattern STOCK_INDENT                    ,+    pattern STOCK_HOME                      ,+    pattern STOCK_HELP                      ,+    pattern STOCK_HARDDISK                  ,+    pattern STOCK_GO_UP                     ,+    pattern STOCK_GO_FORWARD                ,+    pattern STOCK_GO_DOWN                   ,+    pattern STOCK_GO_BACK                   ,+    pattern STOCK_GOTO_TOP                  ,+    pattern STOCK_GOTO_LAST                 ,+    pattern STOCK_GOTO_FIRST                ,+    pattern STOCK_GOTO_BOTTOM               ,+    pattern STOCK_FULLSCREEN                ,+    pattern STOCK_FLOPPY                    ,+    pattern STOCK_FIND_AND_REPLACE          ,+    pattern STOCK_FIND                      ,+    pattern STOCK_FILE                      ,+    pattern STOCK_EXECUTE                   ,+    pattern STOCK_EDIT                      ,+    pattern STOCK_DND_MULTIPLE              ,+    pattern STOCK_DND                       ,+    pattern STOCK_DISCONNECT                ,+    pattern STOCK_DISCARD                   ,+    pattern STOCK_DIRECTORY                 ,+    pattern STOCK_DIALOG_WARNING            ,+    pattern STOCK_DIALOG_QUESTION           ,+    pattern STOCK_DIALOG_INFO               ,+    pattern STOCK_DIALOG_ERROR              ,+    pattern STOCK_DIALOG_AUTHENTICATION     ,+    pattern STOCK_DELETE                    ,+    pattern STOCK_CUT                       ,+    pattern STOCK_COPY                      ,+    pattern STOCK_CONVERT                   ,+    pattern STOCK_CONNECT                   ,+    pattern STOCK_COLOR_PICKER              ,+    pattern STOCK_CLOSE                     ,+    pattern STOCK_CLEAR                     ,+    pattern STOCK_CDROM                     ,+    pattern STOCK_CAPS_LOCK_WARNING         ,+    pattern STOCK_CANCEL                    ,+    pattern STOCK_BOLD                      ,+    pattern STOCK_APPLY                     ,+    pattern STOCK_ADD                       ,+    pattern STOCK_ABOUT                     ,+    pattern PRIORITY_RESIZE                 ,+    pattern PRINT_SETTINGS_WIN32_DRIVER_VERSION,+    pattern PRINT_SETTINGS_WIN32_DRIVER_EXTRA,+    pattern PRINT_SETTINGS_USE_COLOR        ,+    pattern PRINT_SETTINGS_SCALE            ,+    pattern PRINT_SETTINGS_REVERSE          ,+    pattern PRINT_SETTINGS_RESOLUTION_Y     ,+    pattern PRINT_SETTINGS_RESOLUTION_X     ,+    pattern PRINT_SETTINGS_RESOLUTION       ,+    pattern PRINT_SETTINGS_QUALITY          ,+    pattern PRINT_SETTINGS_PRINT_PAGES      ,+    pattern PRINT_SETTINGS_PRINTER_LPI      ,+    pattern PRINT_SETTINGS_PRINTER          ,+    pattern PRINT_SETTINGS_PAPER_WIDTH      ,+    pattern PRINT_SETTINGS_PAPER_HEIGHT     ,+    pattern PRINT_SETTINGS_PAPER_FORMAT     ,+    pattern PRINT_SETTINGS_PAGE_SET         ,+    pattern PRINT_SETTINGS_PAGE_RANGES      ,+    pattern PRINT_SETTINGS_OUTPUT_URI       ,+    pattern PRINT_SETTINGS_OUTPUT_FILE_FORMAT,+    pattern PRINT_SETTINGS_OUTPUT_DIR       ,+    pattern PRINT_SETTINGS_OUTPUT_BIN       ,+    pattern PRINT_SETTINGS_OUTPUT_BASENAME  ,+    pattern PRINT_SETTINGS_ORIENTATION      ,+    pattern PRINT_SETTINGS_N_COPIES         ,+    pattern PRINT_SETTINGS_NUMBER_UP_LAYOUT ,+    pattern PRINT_SETTINGS_NUMBER_UP        ,+    pattern PRINT_SETTINGS_MEDIA_TYPE       ,+    pattern PRINT_SETTINGS_FINISHINGS       ,+    pattern PRINT_SETTINGS_DUPLEX           ,+    pattern PRINT_SETTINGS_DITHER           ,+    pattern PRINT_SETTINGS_DEFAULT_SOURCE   ,+    pattern PRINT_SETTINGS_COLLATE          ,+    pattern PATH_PRIO_MASK                  ,+    pattern PAPER_NAME_LETTER               ,+    pattern PAPER_NAME_LEGAL                ,+    pattern PAPER_NAME_EXECUTIVE            ,+    pattern PAPER_NAME_B5                   ,+    pattern PAPER_NAME_A5                   ,+    pattern PAPER_NAME_A4                   ,+    pattern PAPER_NAME_A3                   ,+    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAX_COMPOSE_LEN                 ,+    pattern MAJOR_VERSION                   ,+    pattern LEVEL_BAR_OFFSET_LOW            ,+    pattern LEVEL_BAR_OFFSET_HIGH           ,+    pattern INTERFACE_AGE                   ,+    pattern INPUT_ERROR                     ,+    pattern BINARY_AGE                      ,++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+++pattern TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID = -2 :: Int32+++pattern TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1 :: Int32+++pattern TEXT_VIEW_PRIORITY_VALIDATE = 5 :: Int32+++pattern STYLE_REGION_TAB = "tab" :: T.Text+++pattern STYLE_REGION_ROW = "row" :: T.Text+++pattern STYLE_REGION_COLUMN_HEADER = "column-header" :: T.Text+++pattern STYLE_REGION_COLUMN = "column" :: T.Text+++pattern STYLE_PROVIDER_PRIORITY_USER = 800 :: Int32+++pattern STYLE_PROVIDER_PRIORITY_THEME = 200 :: Int32+++pattern STYLE_PROVIDER_PRIORITY_SETTINGS = 400 :: Int32+++pattern STYLE_PROVIDER_PRIORITY_FALLBACK = 1 :: Int32+++pattern STYLE_PROVIDER_PRIORITY_APPLICATION = 600 :: Int32+++pattern STYLE_PROPERTY_PADDING = "padding" :: T.Text+++pattern STYLE_PROPERTY_MARGIN = "margin" :: T.Text+++pattern STYLE_PROPERTY_FONT = "font" :: T.Text+++pattern STYLE_PROPERTY_COLOR = "color" :: T.Text+++pattern STYLE_PROPERTY_BORDER_WIDTH = "border-width" :: T.Text+++pattern STYLE_PROPERTY_BORDER_STYLE = "border-style" :: T.Text+++pattern STYLE_PROPERTY_BORDER_RADIUS = "border-radius" :: T.Text+++pattern STYLE_PROPERTY_BORDER_COLOR = "border-color" :: T.Text+++pattern STYLE_PROPERTY_BACKGROUND_IMAGE = "background-image" :: T.Text+++pattern STYLE_PROPERTY_BACKGROUND_COLOR = "background-color" :: T.Text+++pattern STYLE_CLASS_WIDE = "wide" :: T.Text+++pattern STYLE_CLASS_WARNING = "warning" :: T.Text+++pattern STYLE_CLASS_VIEW = "view" :: T.Text+++pattern STYLE_CLASS_VERTICAL = "vertical" :: T.Text+++pattern STYLE_CLASS_UNDERSHOOT = "undershoot" :: T.Text+++pattern STYLE_CLASS_TROUGH = "trough" :: T.Text+++pattern STYLE_CLASS_TOUCH_SELECTION = "touch-selection" :: T.Text+++pattern STYLE_CLASS_TOP = "top" :: T.Text+++pattern STYLE_CLASS_TOOLTIP = "tooltip" :: T.Text+++pattern STYLE_CLASS_TOOLBAR = "toolbar" :: T.Text+++pattern STYLE_CLASS_TITLEBAR = "titlebar" :: T.Text+++pattern STYLE_CLASS_TITLE = "title" :: T.Text+++pattern STYLE_CLASS_SUGGESTED_ACTION = "suggested-action" :: T.Text+++pattern STYLE_CLASS_SUBTITLE = "subtitle" :: T.Text+++pattern STYLE_CLASS_STATUSBAR = "statusbar" :: T.Text+++pattern STYLE_CLASS_SPINNER = "spinner" :: T.Text+++pattern STYLE_CLASS_SPINBUTTON = "spinbutton" :: T.Text+++pattern STYLE_CLASS_SLIDER = "slider" :: T.Text+++pattern STYLE_CLASS_SIDEBAR = "sidebar" :: T.Text+++pattern STYLE_CLASS_SEPARATOR = "separator" :: T.Text+++pattern STYLE_CLASS_SCROLLBARS_JUNCTION = "scrollbars-junction" :: T.Text+++pattern STYLE_CLASS_SCROLLBAR = "scrollbar" :: T.Text+++pattern STYLE_CLASS_SCALE_HAS_MARKS_BELOW = "scale-has-marks-below" :: T.Text+++pattern STYLE_CLASS_SCALE_HAS_MARKS_ABOVE = "scale-has-marks-above" :: T.Text+++pattern STYLE_CLASS_SCALE = "scale" :: T.Text+++pattern STYLE_CLASS_RUBBERBAND = "rubberband" :: T.Text+++pattern STYLE_CLASS_RIGHT = "right" :: T.Text+++pattern STYLE_CLASS_READ_ONLY = "read-only" :: T.Text+++pattern STYLE_CLASS_RAISED = "raised" :: T.Text+++pattern STYLE_CLASS_RADIO = "radio" :: T.Text+++pattern STYLE_CLASS_QUESTION = "question" :: T.Text+++pattern STYLE_CLASS_PULSE = "pulse" :: T.Text+++pattern STYLE_CLASS_PROGRESSBAR = "progressbar" :: T.Text+++pattern STYLE_CLASS_PRIMARY_TOOLBAR = "primary-toolbar" :: T.Text+++pattern STYLE_CLASS_POPUP = "popup" :: T.Text+++pattern STYLE_CLASS_POPOVER = "popover" :: T.Text+++pattern STYLE_CLASS_PAPER = "paper" :: T.Text+++pattern STYLE_CLASS_PANE_SEPARATOR = "pane-separator" :: T.Text+++pattern STYLE_CLASS_OVERSHOOT = "overshoot" :: T.Text+++pattern STYLE_CLASS_OSD = "osd" :: T.Text+++pattern STYLE_CLASS_NOTEBOOK = "notebook" :: T.Text+++pattern STYLE_CLASS_NEEDS_ATTENTION = "needs-attention" :: T.Text+++pattern STYLE_CLASS_MONOSPACE = "monospace" :: T.Text+++pattern STYLE_CLASS_MESSAGE_DIALOG = "message-dialog" :: T.Text+++pattern STYLE_CLASS_MENUITEM = "menuitem" :: T.Text+++pattern STYLE_CLASS_MENUBAR = "menubar" :: T.Text+++pattern STYLE_CLASS_MENU = "menu" :: T.Text+++pattern STYLE_CLASS_MARK = "mark" :: T.Text+++pattern STYLE_CLASS_LIST_ROW = "list-row" :: T.Text+++pattern STYLE_CLASS_LIST = "list" :: T.Text+++pattern STYLE_CLASS_LINKED = "linked" :: T.Text+++pattern STYLE_CLASS_LEVEL_BAR = "level-bar" :: T.Text+++pattern STYLE_CLASS_LEFT = "left" :: T.Text+++pattern STYLE_CLASS_LABEL = "label" :: T.Text+++pattern STYLE_CLASS_INSERTION_CURSOR = "insertion-cursor" :: T.Text+++pattern STYLE_CLASS_INLINE_TOOLBAR = "inline-toolbar" :: T.Text+++pattern STYLE_CLASS_INFO = "info" :: T.Text+++pattern STYLE_CLASS_IMAGE = "image" :: T.Text+++pattern STYLE_CLASS_HORIZONTAL = "horizontal" :: T.Text+++pattern STYLE_CLASS_HIGHLIGHT = "highlight" :: T.Text+++pattern STYLE_CLASS_HEADER = "header" :: T.Text+++pattern STYLE_CLASS_GRIP = "grip" :: T.Text+++pattern STYLE_CLASS_FRAME = "frame" :: T.Text+++pattern STYLE_CLASS_FLAT = "flat" :: T.Text+++pattern STYLE_CLASS_EXPANDER = "expander" :: T.Text+++pattern STYLE_CLASS_ERROR = "error" :: T.Text+++pattern STYLE_CLASS_ENTRY = "entry" :: T.Text+++pattern STYLE_CLASS_DOCK = "dock" :: T.Text+++pattern STYLE_CLASS_DND = "dnd" :: T.Text+++pattern STYLE_CLASS_DIM_LABEL = "dim-label" :: T.Text+++pattern STYLE_CLASS_DESTRUCTIVE_ACTION = "destructive-action" :: T.Text+++pattern STYLE_CLASS_DEFAULT = "default" :: T.Text+++pattern STYLE_CLASS_CURSOR_HANDLE = "cursor-handle" :: T.Text+++pattern STYLE_CLASS_CSD = "csd" :: T.Text+++pattern STYLE_CLASS_CONTEXT_MENU = "context-menu" :: T.Text+++pattern STYLE_CLASS_COMBOBOX_ENTRY = "combobox-entry" :: T.Text+++pattern STYLE_CLASS_CHECK = "check" :: T.Text+++pattern STYLE_CLASS_CELL = "cell" :: T.Text+++pattern STYLE_CLASS_CALENDAR = "calendar" :: T.Text+++pattern STYLE_CLASS_BUTTON = "button" :: T.Text+++pattern STYLE_CLASS_BOTTOM = "bottom" :: T.Text+++pattern STYLE_CLASS_BACKGROUND = "background" :: T.Text+++pattern STYLE_CLASS_ARROW = "arrow" :: T.Text+++pattern STYLE_CLASS_ACCELERATOR = "accelerator" :: T.Text++{-# DEPRECATED STOCK_ZOOM_OUT ["(Since version 3.10)","Use named icon &quot;zoom-out&quot; or the label &quot;Zoom _Out&quot;."]#-}+pattern STOCK_ZOOM_OUT = "gtk-zoom-out" :: T.Text++{-# DEPRECATED STOCK_ZOOM_IN ["(Since version 3.10)","Use named icon &quot;zoom-in&quot; or the label &quot;Zoom _In&quot;."]#-}+pattern STOCK_ZOOM_IN = "gtk-zoom-in" :: T.Text++{-# DEPRECATED STOCK_ZOOM_FIT ["(Since version 3.10)","Use named icon &quot;zoom-fit-best&quot; or the label &quot;Best _Fit&quot;."]#-}+pattern STOCK_ZOOM_FIT = "gtk-zoom-fit" :: T.Text++{-# DEPRECATED STOCK_ZOOM_100 ["(Since version 3.10)","Use named icon &quot;zoom-original&quot; or the label &quot;_Normal Size&quot;."]#-}+pattern STOCK_ZOOM_100 = "gtk-zoom-100" :: T.Text++{-# DEPRECATED STOCK_YES ["(Since version 3.10)"]#-}+pattern STOCK_YES = "gtk-yes" :: T.Text++{-# DEPRECATED STOCK_UNINDENT ["(Since version 3.10)","Use named icon &quot;format-indent-less&quot;."]#-}+pattern STOCK_UNINDENT = "gtk-unindent" :: T.Text++{-# DEPRECATED STOCK_UNDO ["(Since version 3.10)","Use named icon &quot;edit-undo&quot; or the label &quot;_Undo&quot;."]#-}+pattern STOCK_UNDO = "gtk-undo" :: T.Text++{-# DEPRECATED STOCK_UNDERLINE ["(Since version 3.10)","Use named icon &quot;format-text-underline&quot; or the label &quot;_Underline&quot;."]#-}+pattern STOCK_UNDERLINE = "gtk-underline" :: T.Text++{-# DEPRECATED STOCK_UNDELETE ["(Since version 3.10)"]#-}+pattern STOCK_UNDELETE = "gtk-undelete" :: T.Text++{-# DEPRECATED STOCK_STRIKETHROUGH ["(Since version 3.10)","Use named icon &quot;format-text-strikethrough&quot; or the label &quot;_Strikethrough&quot;."]#-}+pattern STOCK_STRIKETHROUGH = "gtk-strikethrough" :: T.Text++{-# DEPRECATED STOCK_STOP ["(Since version 3.10)","Use named icon &quot;process-stop&quot; or the label &quot;_Stop&quot;."]#-}+pattern STOCK_STOP = "gtk-stop" :: T.Text++{-# DEPRECATED STOCK_SPELL_CHECK ["(Since version 3.10)","Use named icon &quot;tools-check-spelling&quot;."]#-}+pattern STOCK_SPELL_CHECK = "gtk-spell-check" :: T.Text++{-# DEPRECATED STOCK_SORT_DESCENDING ["(Since version 3.10)","Use named icon &quot;view-sort-descending&quot;."]#-}+pattern STOCK_SORT_DESCENDING = "gtk-sort-descending" :: T.Text++{-# DEPRECATED STOCK_SORT_ASCENDING ["(Since version 3.10)","Use named icon &quot;view-sort-ascending&quot;."]#-}+pattern STOCK_SORT_ASCENDING = "gtk-sort-ascending" :: T.Text++{-# DEPRECATED STOCK_SELECT_FONT ["(Since version 3.10)"]#-}+pattern STOCK_SELECT_FONT = "gtk-select-font" :: T.Text++{-# DEPRECATED STOCK_SELECT_COLOR ["(Since version 3.10)"]#-}+pattern STOCK_SELECT_COLOR = "gtk-select-color" :: T.Text++{-# DEPRECATED STOCK_SELECT_ALL ["(Since version 3.10)","Use named icon &quot;edit-select-all&quot; or the label &quot;Select _All&quot;."]#-}+pattern STOCK_SELECT_ALL = "gtk-select-all" :: T.Text++{-# DEPRECATED STOCK_SAVE_AS ["(Since version 3.10)","Use named icon &quot;document-save-as&quot; or the label &quot;Save _As&quot;."]#-}+pattern STOCK_SAVE_AS = "gtk-save-as" :: T.Text++{-# DEPRECATED STOCK_SAVE ["(Since version 3.10)","Use named icon &quot;document-save&quot; or the label &quot;_Save&quot;."]#-}+pattern STOCK_SAVE = "gtk-save" :: T.Text++{-# DEPRECATED STOCK_REVERT_TO_SAVED ["(Since version 3.10)","Use named icon &quot;document-revert&quot; or the label &quot;_Revert&quot;."]#-}+pattern STOCK_REVERT_TO_SAVED = "gtk-revert-to-saved" :: T.Text++{-# DEPRECATED STOCK_REMOVE ["(Since version 3.10)","Use named icon &quot;list-remove&quot; or the label &quot;_Remove&quot;."]#-}+pattern STOCK_REMOVE = "gtk-remove" :: T.Text++{-# DEPRECATED STOCK_REFRESH ["(Since version 3.10)","Use named icon &quot;view-refresh&quot; or the label &quot;_Refresh&quot;."]#-}+pattern STOCK_REFRESH = "gtk-refresh" :: T.Text++{-# DEPRECATED STOCK_REDO ["(Since version 3.10)","Use named icon &quot;edit-redo&quot; or the label &quot;_Redo&quot;."]#-}+pattern STOCK_REDO = "gtk-redo" :: T.Text++{-# DEPRECATED STOCK_QUIT ["(Since version 3.10)","Use named icon &quot;application-exit&quot; or the label &quot;_Quit&quot;."]#-}+pattern STOCK_QUIT = "gtk-quit" :: T.Text++{-# DEPRECATED STOCK_PROPERTIES ["(Since version 3.10)","Use named icon &quot;document-properties&quot; or the label &quot;_Properties&quot;."]#-}+pattern STOCK_PROPERTIES = "gtk-properties" :: T.Text++{-# DEPRECATED STOCK_PRINT_WARNING ["(Since version 3.10)"]#-}+pattern STOCK_PRINT_WARNING = "gtk-print-warning" :: T.Text++{-# DEPRECATED STOCK_PRINT_REPORT ["(Since version 3.10)"]#-}+pattern STOCK_PRINT_REPORT = "gtk-print-report" :: T.Text++{-# DEPRECATED STOCK_PRINT_PREVIEW ["(Since version 3.10)","Use label &quot;Pre_view&quot;."]#-}+pattern STOCK_PRINT_PREVIEW = "gtk-print-preview" :: T.Text++{-# DEPRECATED STOCK_PRINT_PAUSED ["(Since version 3.10)"]#-}+pattern STOCK_PRINT_PAUSED = "gtk-print-paused" :: T.Text++{-# DEPRECATED STOCK_PRINT_ERROR ["(Since version 3.10)","Use named icon &quot;printer-error&quot;."]#-}+pattern STOCK_PRINT_ERROR = "gtk-print-error" :: T.Text++{-# DEPRECATED STOCK_PRINT ["(Since version 3.10)","Use named icon &quot;document-print&quot; or the label &quot;_Print&quot;."]#-}+pattern STOCK_PRINT = "gtk-print" :: T.Text++{-# DEPRECATED STOCK_PREFERENCES ["(Since version 3.10)","Use named icon &quot;preferences-system&quot; or the label &quot;_Preferences&quot;."]#-}+pattern STOCK_PREFERENCES = "gtk-preferences" :: T.Text++{-# DEPRECATED STOCK_PASTE ["(Since version 3.10)","Use named icon &quot;edit-paste&quot; or the label &quot;_Paste&quot;."]#-}+pattern STOCK_PASTE = "gtk-paste" :: T.Text++{-# DEPRECATED STOCK_PAGE_SETUP ["(Since version 3.10)","Use named icon &quot;document-page-setup&quot; or the label &quot;Page Set_up&quot;."]#-}+pattern STOCK_PAGE_SETUP = "gtk-page-setup" :: T.Text++{-# DEPRECATED STOCK_ORIENTATION_REVERSE_PORTRAIT ["(Since version 3.10)"]#-}+pattern STOCK_ORIENTATION_REVERSE_PORTRAIT = "gtk-orientation-reverse-portrait" :: T.Text++{-# DEPRECATED STOCK_ORIENTATION_REVERSE_LANDSCAPE ["(Since version 3.10)"]#-}+pattern STOCK_ORIENTATION_REVERSE_LANDSCAPE = "gtk-orientation-reverse-landscape" :: T.Text++{-# DEPRECATED STOCK_ORIENTATION_PORTRAIT ["(Since version 3.10)"]#-}+pattern STOCK_ORIENTATION_PORTRAIT = "gtk-orientation-portrait" :: T.Text++{-# DEPRECATED STOCK_ORIENTATION_LANDSCAPE ["(Since version 3.10)"]#-}+pattern STOCK_ORIENTATION_LANDSCAPE = "gtk-orientation-landscape" :: T.Text++{-# DEPRECATED STOCK_OPEN ["(Since version 3.10)","Use named icon &quot;document-open&quot; or the label &quot;_Open&quot;."]#-}+pattern STOCK_OPEN = "gtk-open" :: T.Text++{-# DEPRECATED STOCK_OK ["(Since version 3.10)","Do not use an icon. Use label &quot;_OK&quot;."]#-}+pattern STOCK_OK = "gtk-ok" :: T.Text++{-# DEPRECATED STOCK_NO ["(Since version 3.10)"]#-}+pattern STOCK_NO = "gtk-no" :: T.Text++{-# DEPRECATED STOCK_NEW ["(Since version 3.10)","Use named icon &quot;document-new&quot; or the label &quot;_New&quot;."]#-}+pattern STOCK_NEW = "gtk-new" :: T.Text++{-# DEPRECATED STOCK_NETWORK ["(Since version 3.10)","Use named icon &quot;network-workgroup&quot;."]#-}+pattern STOCK_NETWORK = "gtk-network" :: T.Text++{-# DEPRECATED STOCK_MISSING_IMAGE ["(Since version 3.10)","Use named icon &quot;image-missing&quot;."]#-}+pattern STOCK_MISSING_IMAGE = "gtk-missing-image" :: T.Text++{-# DEPRECATED STOCK_MEDIA_STOP ["(Since version 3.10)","Use named icon &quot;media-playback-stop&quot; or the label &quot;_Stop&quot;."]#-}+pattern STOCK_MEDIA_STOP = "gtk-media-stop" :: T.Text++{-# DEPRECATED STOCK_MEDIA_REWIND ["(Since version 3.10)","Use named icon &quot;media-seek-backward&quot; or the label &quot;R_ewind&quot;."]#-}+pattern STOCK_MEDIA_REWIND = "gtk-media-rewind" :: T.Text++{-# DEPRECATED STOCK_MEDIA_RECORD ["(Since version 3.10)","Use named icon &quot;media-record&quot; or the label &quot;_Record&quot;."]#-}+pattern STOCK_MEDIA_RECORD = "gtk-media-record" :: T.Text++{-# DEPRECATED STOCK_MEDIA_PREVIOUS ["(Since version 3.10)","Use named icon &quot;media-skip-backward&quot; or the label &quot;Pre_vious&quot;."]#-}+pattern STOCK_MEDIA_PREVIOUS = "gtk-media-previous" :: T.Text++{-# DEPRECATED STOCK_MEDIA_PLAY ["(Since version 3.10)","Use named icon &quot;media-playback-start&quot; or the label &quot;_Play&quot;."]#-}+pattern STOCK_MEDIA_PLAY = "gtk-media-play" :: T.Text++{-# DEPRECATED STOCK_MEDIA_PAUSE ["(Since version 3.10)","Use named icon &quot;media-playback-pause&quot; or the label &quot;P_ause&quot;."]#-}+pattern STOCK_MEDIA_PAUSE = "gtk-media-pause" :: T.Text++{-# DEPRECATED STOCK_MEDIA_NEXT ["(Since version 3.10)","Use named icon &quot;media-skip-forward&quot; or the label &quot;_Next&quot;."]#-}+pattern STOCK_MEDIA_NEXT = "gtk-media-next" :: T.Text++{-# DEPRECATED STOCK_MEDIA_FORWARD ["(Since version 3.10)","Use named icon &quot;media-seek-forward&quot; or the label &quot;_Forward&quot;."]#-}+pattern STOCK_MEDIA_FORWARD = "gtk-media-forward" :: T.Text++{-# DEPRECATED STOCK_LEAVE_FULLSCREEN ["(Since version 3.10)","Use named icon &quot;view-restore&quot;."]#-}+pattern STOCK_LEAVE_FULLSCREEN = "gtk-leave-fullscreen" :: T.Text++{-# DEPRECATED STOCK_JUSTIFY_RIGHT ["(Since version 3.10)","Use named icon &quot;format-justify-right&quot;."]#-}+pattern STOCK_JUSTIFY_RIGHT = "gtk-justify-right" :: T.Text++{-# DEPRECATED STOCK_JUSTIFY_LEFT ["(Since version 3.10)","Use named icon &quot;format-justify-left&quot;."]#-}+pattern STOCK_JUSTIFY_LEFT = "gtk-justify-left" :: T.Text++{-# DEPRECATED STOCK_JUSTIFY_FILL ["(Since version 3.10)","Use named icon &quot;format-justify-fill&quot;."]#-}+pattern STOCK_JUSTIFY_FILL = "gtk-justify-fill" :: T.Text++{-# DEPRECATED STOCK_JUSTIFY_CENTER ["(Since version 3.10)","Use named icon &quot;format-justify-center&quot;."]#-}+pattern STOCK_JUSTIFY_CENTER = "gtk-justify-center" :: T.Text++{-# DEPRECATED STOCK_JUMP_TO ["(Since version 3.10)","Use named icon &quot;go-jump&quot;."]#-}+pattern STOCK_JUMP_TO = "gtk-jump-to" :: T.Text++{-# DEPRECATED STOCK_ITALIC ["(Since version 3.10)","Use named icon &quot;format-text-italic&quot;."]#-}+pattern STOCK_ITALIC = "gtk-italic" :: T.Text++{-# DEPRECATED STOCK_INFO ["(Since version 3.10)","Use named icon &quot;dialog-information&quot;."]#-}+pattern STOCK_INFO = "gtk-info" :: T.Text++{-# DEPRECATED STOCK_INDEX ["(Since version 3.10)"]#-}+pattern STOCK_INDEX = "gtk-index" :: T.Text++{-# DEPRECATED STOCK_INDENT ["(Since version 3.10)","Use named icon &quot;format-indent-more&quot;."]#-}+pattern STOCK_INDENT = "gtk-indent" :: T.Text++{-# DEPRECATED STOCK_HOME ["(Since version 3.10)","Use named icon &quot;go-home&quot;."]#-}+pattern STOCK_HOME = "gtk-home" :: T.Text++{-# DEPRECATED STOCK_HELP ["(Since version 3.10)","Use named icon &quot;help-browser&quot;."]#-}+pattern STOCK_HELP = "gtk-help" :: T.Text++{-# DEPRECATED STOCK_HARDDISK ["(Since version 3.10)","Use named icon &quot;drive-harddisk&quot;."]#-}+pattern STOCK_HARDDISK = "gtk-harddisk" :: T.Text++{-# DEPRECATED STOCK_GO_UP ["(Since version 3.10)","Use named icon &quot;go-up&quot;."]#-}+pattern STOCK_GO_UP = "gtk-go-up" :: T.Text++{-# DEPRECATED STOCK_GO_FORWARD ["(Since version 3.10)","Use named icon &quot;go-next&quot;."]#-}+pattern STOCK_GO_FORWARD = "gtk-go-forward" :: T.Text++{-# DEPRECATED STOCK_GO_DOWN ["(Since version 3.10)","Use named icon &quot;go-down&quot;."]#-}+pattern STOCK_GO_DOWN = "gtk-go-down" :: T.Text++{-# DEPRECATED STOCK_GO_BACK ["(Since version 3.10)","Use named icon &quot;go-previous&quot;."]#-}+pattern STOCK_GO_BACK = "gtk-go-back" :: T.Text++{-# DEPRECATED STOCK_GOTO_TOP ["(Since version 3.10)","Use named icon &quot;go-top&quot;."]#-}+pattern STOCK_GOTO_TOP = "gtk-goto-top" :: T.Text++{-# DEPRECATED STOCK_GOTO_LAST ["(Since version 3.10)","Use named icon &quot;go-last&quot;."]#-}+pattern STOCK_GOTO_LAST = "gtk-goto-last" :: T.Text++{-# DEPRECATED STOCK_GOTO_FIRST ["(Since version 3.10)","Use named icon &quot;go-first&quot;."]#-}+pattern STOCK_GOTO_FIRST = "gtk-goto-first" :: T.Text++{-# DEPRECATED STOCK_GOTO_BOTTOM ["(Since version 3.10)","Use named icon &quot;go-bottom&quot;."]#-}+pattern STOCK_GOTO_BOTTOM = "gtk-goto-bottom" :: T.Text++{-# DEPRECATED STOCK_FULLSCREEN ["(Since version 3.10)","Use named icon &quot;view-fullscreen&quot;."]#-}+pattern STOCK_FULLSCREEN = "gtk-fullscreen" :: T.Text++{-# DEPRECATED STOCK_FLOPPY ["(Since version 3.10)"]#-}+pattern STOCK_FLOPPY = "gtk-floppy" :: T.Text++{-# DEPRECATED STOCK_FIND_AND_REPLACE ["(Since version 3.10)","Use named icon &quot;edit-find-replace&quot;."]#-}+pattern STOCK_FIND_AND_REPLACE = "gtk-find-and-replace" :: T.Text++{-# DEPRECATED STOCK_FIND ["(Since version 3.10)","Use named icon &quot;edit-find&quot;."]#-}+pattern STOCK_FIND = "gtk-find" :: T.Text++{-# DEPRECATED STOCK_FILE ["(Since version 3.10)","Use named icon &quot;text-x-generic&quot;."]#-}+pattern STOCK_FILE = "gtk-file" :: T.Text++{-# DEPRECATED STOCK_EXECUTE ["(Since version 3.10)","Use named icon &quot;system-run&quot;."]#-}+pattern STOCK_EXECUTE = "gtk-execute" :: T.Text++{-# DEPRECATED STOCK_EDIT ["(Since version 3.10)"]#-}+pattern STOCK_EDIT = "gtk-edit" :: T.Text++{-# DEPRECATED STOCK_DND_MULTIPLE ["(Since version 3.10)"]#-}+pattern STOCK_DND_MULTIPLE = "gtk-dnd-multiple" :: T.Text++{-# DEPRECATED STOCK_DND ["(Since version 3.10)"]#-}+pattern STOCK_DND = "gtk-dnd" :: T.Text++{-# DEPRECATED STOCK_DISCONNECT ["(Since version 3.10)"]#-}+pattern STOCK_DISCONNECT = "gtk-disconnect" :: T.Text++{-# DEPRECATED STOCK_DISCARD ["(Since version 3.10)"]#-}+pattern STOCK_DISCARD = "gtk-discard" :: T.Text++{-# DEPRECATED STOCK_DIRECTORY ["(Since version 3.10)","Use named icon &quot;folder&quot;."]#-}+pattern STOCK_DIRECTORY = "gtk-directory" :: T.Text++{-# DEPRECATED STOCK_DIALOG_WARNING ["(Since version 3.10)","Use named icon &quot;dialog-warning&quot;."]#-}+pattern STOCK_DIALOG_WARNING = "gtk-dialog-warning" :: T.Text++{-# DEPRECATED STOCK_DIALOG_QUESTION ["(Since version 3.10)","Use named icon &quot;dialog-question&quot;."]#-}+pattern STOCK_DIALOG_QUESTION = "gtk-dialog-question" :: T.Text++{-# DEPRECATED STOCK_DIALOG_INFO ["(Since version 3.10)","Use named icon &quot;dialog-information&quot;."]#-}+pattern STOCK_DIALOG_INFO = "gtk-dialog-info" :: T.Text++{-# DEPRECATED STOCK_DIALOG_ERROR ["(Since version 3.10)","Use named icon &quot;dialog-error&quot;."]#-}+pattern STOCK_DIALOG_ERROR = "gtk-dialog-error" :: T.Text++{-# DEPRECATED STOCK_DIALOG_AUTHENTICATION ["(Since version 3.10)","Use named icon &quot;dialog-password&quot;."]#-}+pattern STOCK_DIALOG_AUTHENTICATION = "gtk-dialog-authentication" :: T.Text++{-# DEPRECATED STOCK_DELETE ["(Since version 3.10)","Use the named icon &quot;edit-delete&quot; or the label &quot;_Delete&quot;."]#-}+pattern STOCK_DELETE = "gtk-delete" :: T.Text++{-# DEPRECATED STOCK_CUT ["(Since version 3.10)","Use the named icon &quot;edit-cut&quot; or the label &quot;Cu_t&quot;."]#-}+pattern STOCK_CUT = "gtk-cut" :: T.Text++{-# DEPRECATED STOCK_COPY ["(Since version 3.10)","Use the named icon &quot;edit-copy&quot; or the label &quot;_Copy&quot;."]#-}+pattern STOCK_COPY = "gtk-copy" :: T.Text++{-# DEPRECATED STOCK_CONVERT ["(Since version 3.10)"]#-}+pattern STOCK_CONVERT = "gtk-convert" :: T.Text++{-# DEPRECATED STOCK_CONNECT ["(Since version 3.10)"]#-}+pattern STOCK_CONNECT = "gtk-connect" :: T.Text++{-# DEPRECATED STOCK_COLOR_PICKER ["(Since version 3.10)"]#-}+pattern STOCK_COLOR_PICKER = "gtk-color-picker" :: T.Text++{-# DEPRECATED STOCK_CLOSE ["(Since version 3.10)","Use named icon &quot;window-close&quot; or the label &quot;_Close&quot;."]#-}+pattern STOCK_CLOSE = "gtk-close" :: T.Text++{-# DEPRECATED STOCK_CLEAR ["(Since version 3.10)","Use named icon &quot;edit-clear&quot;."]#-}+pattern STOCK_CLEAR = "gtk-clear" :: T.Text++{-# DEPRECATED STOCK_CDROM ["(Since version 3.10)","Use named icon &quot;media-optical&quot;."]#-}+pattern STOCK_CDROM = "gtk-cdrom" :: T.Text++{-# DEPRECATED STOCK_CAPS_LOCK_WARNING ["(Since version 3.10)","Use named icon &quot;dialog-warning-symbolic&quot;."]#-}+pattern STOCK_CAPS_LOCK_WARNING = "gtk-caps-lock-warning" :: T.Text++{-# DEPRECATED STOCK_CANCEL ["(Since version 3.10)","Do not use an icon. Use label &quot;_Cancel&quot;."]#-}+pattern STOCK_CANCEL = "gtk-cancel" :: T.Text++{-# DEPRECATED STOCK_BOLD ["(Since version 3.10)","Use named icon &quot;format-text-bold&quot;."]#-}+pattern STOCK_BOLD = "gtk-bold" :: T.Text++{-# DEPRECATED STOCK_APPLY ["(Since version 3.10)","Do not use an icon. Use label &quot;_Apply&quot;."]#-}+pattern STOCK_APPLY = "gtk-apply" :: T.Text++{-# DEPRECATED STOCK_ADD ["(Since version 3.10)","Use named icon &quot;list-add&quot; or the label &quot;_Add&quot;."]#-}+pattern STOCK_ADD = "gtk-add" :: T.Text++{-# DEPRECATED STOCK_ABOUT ["(Since version 3.10)","Use named icon &quot;help-about&quot; or the label &quot;_About&quot;."]#-}+pattern STOCK_ABOUT = "gtk-about" :: T.Text+++pattern PRIORITY_RESIZE = 10 :: Int32+++pattern PRINT_SETTINGS_WIN32_DRIVER_VERSION = "win32-driver-version" :: T.Text+++pattern PRINT_SETTINGS_WIN32_DRIVER_EXTRA = "win32-driver-extra" :: T.Text+++pattern PRINT_SETTINGS_USE_COLOR = "use-color" :: T.Text+++pattern PRINT_SETTINGS_SCALE = "scale" :: T.Text+++pattern PRINT_SETTINGS_REVERSE = "reverse" :: T.Text+++pattern PRINT_SETTINGS_RESOLUTION_Y = "resolution-y" :: T.Text+++pattern PRINT_SETTINGS_RESOLUTION_X = "resolution-x" :: T.Text+++pattern PRINT_SETTINGS_RESOLUTION = "resolution" :: T.Text+++pattern PRINT_SETTINGS_QUALITY = "quality" :: T.Text+++pattern PRINT_SETTINGS_PRINT_PAGES = "print-pages" :: T.Text+++pattern PRINT_SETTINGS_PRINTER_LPI = "printer-lpi" :: T.Text+++pattern PRINT_SETTINGS_PRINTER = "printer" :: T.Text+++pattern PRINT_SETTINGS_PAPER_WIDTH = "paper-width" :: T.Text+++pattern PRINT_SETTINGS_PAPER_HEIGHT = "paper-height" :: T.Text+++pattern PRINT_SETTINGS_PAPER_FORMAT = "paper-format" :: T.Text+++pattern PRINT_SETTINGS_PAGE_SET = "page-set" :: T.Text+++pattern PRINT_SETTINGS_PAGE_RANGES = "page-ranges" :: T.Text+++pattern PRINT_SETTINGS_OUTPUT_URI = "output-uri" :: T.Text+++pattern PRINT_SETTINGS_OUTPUT_FILE_FORMAT = "output-file-format" :: T.Text+++pattern PRINT_SETTINGS_OUTPUT_DIR = "output-dir" :: T.Text+++pattern PRINT_SETTINGS_OUTPUT_BIN = "output-bin" :: T.Text+++pattern PRINT_SETTINGS_OUTPUT_BASENAME = "output-basename" :: T.Text+++pattern PRINT_SETTINGS_ORIENTATION = "orientation" :: T.Text+++pattern PRINT_SETTINGS_N_COPIES = "n-copies" :: T.Text+++pattern PRINT_SETTINGS_NUMBER_UP_LAYOUT = "number-up-layout" :: T.Text+++pattern PRINT_SETTINGS_NUMBER_UP = "number-up" :: T.Text+++pattern PRINT_SETTINGS_MEDIA_TYPE = "media-type" :: T.Text+++pattern PRINT_SETTINGS_FINISHINGS = "finishings" :: T.Text+++pattern PRINT_SETTINGS_DUPLEX = "duplex" :: T.Text+++pattern PRINT_SETTINGS_DITHER = "dither" :: T.Text+++pattern PRINT_SETTINGS_DEFAULT_SOURCE = "default-source" :: T.Text+++pattern PRINT_SETTINGS_COLLATE = "collate" :: T.Text+++pattern PATH_PRIO_MASK = 15 :: Int32+++pattern PAPER_NAME_LETTER = "na_letter" :: T.Text+++pattern PAPER_NAME_LEGAL = "na_legal" :: T.Text+++pattern PAPER_NAME_EXECUTIVE = "na_executive" :: T.Text+++pattern PAPER_NAME_B5 = "iso_b5" :: T.Text+++pattern PAPER_NAME_A5 = "iso_a5" :: T.Text+++pattern PAPER_NAME_A4 = "iso_a4" :: T.Text+++pattern PAPER_NAME_A3 = "iso_a3" :: T.Text+++pattern MINOR_VERSION = 18 :: Int32+++pattern MICRO_VERSION = 6 :: Int32+++pattern MAX_COMPOSE_LEN = 7 :: Int32+++pattern MAJOR_VERSION = 3 :: Int32+++pattern LEVEL_BAR_OFFSET_LOW = "low" :: T.Text+++pattern LEVEL_BAR_OFFSET_HIGH = "high" :: T.Text+++pattern INTERFACE_AGE = 6 :: Int32+++pattern INPUT_ERROR = -1 :: Int32+++pattern BINARY_AGE = 1806 :: Int32++
+ GI/Gtk/Enums.hs view
@@ -0,0 +1,3295 @@++{- |+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.Gtk.Enums+    ( +    catchRecentManagerError                 ,+    handleRecentManagerError                ,+    catchRecentChooserError                 ,+    handleRecentChooserError                ,+    catchPrintError                         ,+    handlePrintError                        ,+    catchIconThemeError                     ,+    handleIconThemeError                    ,+    catchFileChooserError                   ,+    handleFileChooserError                  ,+    catchCssProviderError                   ,+    handleCssProviderError                  ,+    catchBuilderError                       ,+    handleBuilderError                      ,++-- * Exported types+    WrapMode(..)                            ,+    WindowType(..)                          ,+    WindowPosition(..)                      ,+    WidgetHelpType(..)                      ,+    Unit(..)                                ,+    TreeViewGridLines(..)                   ,+    TreeViewDropPosition(..)                ,+    TreeViewColumnSizing(..)                ,+    ToolbarStyle(..)                        ,+    ToolbarSpaceStyle(..)                   ,+    TextWindowType(..)                      ,+    TextViewLayer(..)                       ,+    TextExtendSelection(..)                 ,+    TextDirection(..)                       ,+    TextBufferTargetInfo(..)                ,+    StateType(..)                           ,+    StackTransitionType(..)                 ,+    SpinType(..)                            ,+    SpinButtonUpdatePolicy(..)              ,+    SortType(..)                            ,+    SizeRequestMode(..)                     ,+    SizeGroupMode(..)                       ,+    ShadowType(..)                          ,+    SensitivityType(..)                     ,+    SelectionMode(..)                       ,+    ScrollablePolicy(..)                    ,+    ScrollType(..)                          ,+    ScrollStep(..)                          ,+    RevealerTransitionType(..)              ,+    ResponseType(..)                        ,+    ResizeMode(..)                          ,+    ReliefStyle(..)                         ,+    RecentSortType(..)                      ,+    RecentManagerError(..)                  ,+    RecentChooserError(..)                  ,+    RcTokenType(..)                         ,+    PropagationPhase(..)                    ,+    PrintStatus(..)                         ,+    PrintQuality(..)                        ,+    PrintPages(..)                          ,+    PrintOperationResult(..)                ,+    PrintOperationAction(..)                ,+    PrintError(..)                          ,+    PrintDuplex(..)                         ,+    PositionType(..)                        ,+    PolicyType(..)                          ,+    PathType(..)                            ,+    PathPriorityType(..)                    ,+    PanDirection(..)                        ,+    PageSet(..)                             ,+    PageOrientation(..)                     ,+    PackType(..)                            ,+    PackDirection(..)                       ,+    Orientation(..)                         ,+    NumberUpLayout(..)                      ,+    NotebookTab(..)                         ,+    MovementStep(..)                        ,+    MessageType(..)                         ,+    MenuDirectionType(..)                   ,+    License(..)                             ,+    LevelBarMode(..)                        ,+    Justification(..)                       ,+    InputPurpose(..)                        ,+    ImageType(..)                           ,+    IconViewDropPosition(..)                ,+    IconThemeError(..)                      ,+    IconSize(..)                            ,+    IMStatusStyle(..)                       ,+    IMPreeditStyle(..)                      ,+    FileChooserError(..)                    ,+    FileChooserConfirmation(..)             ,+    FileChooserAction(..)                   ,+    ExpanderStyle(..)                       ,+    EventSequenceState(..)                  ,+    EntryIconPosition(..)                   ,+    DragResult(..)                          ,+    DirectionType(..)                       ,+    DeleteType(..)                          ,+    CssSectionType(..)                      ,+    CssProviderError(..)                    ,+    CornerType(..)                          ,+    CellRendererMode(..)                    ,+    CellRendererAccelMode(..)               ,+    ButtonsType(..)                         ,+    ButtonRole(..)                          ,+    ButtonBoxStyle(..)                      ,+    BuilderError(..)                        ,+    BorderStyle(..)                         ,+    BaselinePosition(..)                    ,+    AssistantPageType(..)                   ,+    ArrowType(..)                           ,+    ArrowPlacement(..)                      ,+    Align(..)                               ,+++    ) where++import Prelude ()+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 WrapMode++data WrapMode = +      WrapModeNone+    | WrapModeChar+    | WrapModeWord+    | WrapModeWordChar+    | AnotherWrapMode Int+    deriving (Show, Eq)++instance Enum WrapMode where+    fromEnum WrapModeNone = 0+    fromEnum WrapModeChar = 1+    fromEnum WrapModeWord = 2+    fromEnum WrapModeWordChar = 3+    fromEnum (AnotherWrapMode k) = k++    toEnum 0 = WrapModeNone+    toEnum 1 = WrapModeChar+    toEnum 2 = WrapModeWord+    toEnum 3 = WrapModeWordChar+    toEnum k = AnotherWrapMode k++foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: +    IO GType++instance BoxedEnum WrapMode where+    boxedEnumType _ = c_gtk_wrap_mode_get_type++-- Enum WindowType++data WindowType = +      WindowTypeToplevel+    | WindowTypePopup+    | AnotherWindowType Int+    deriving (Show, Eq)++instance Enum WindowType where+    fromEnum WindowTypeToplevel = 0+    fromEnum WindowTypePopup = 1+    fromEnum (AnotherWindowType k) = k++    toEnum 0 = WindowTypeToplevel+    toEnum 1 = WindowTypePopup+    toEnum k = AnotherWindowType k++foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type :: +    IO GType++instance BoxedEnum WindowType where+    boxedEnumType _ = c_gtk_window_type_get_type++-- Enum WindowPosition++data WindowPosition = +      WindowPositionNone+    | WindowPositionCenter+    | WindowPositionMouse+    | WindowPositionCenterAlways+    | WindowPositionCenterOnParent+    | AnotherWindowPosition Int+    deriving (Show, Eq)++instance Enum WindowPosition where+    fromEnum WindowPositionNone = 0+    fromEnum WindowPositionCenter = 1+    fromEnum WindowPositionMouse = 2+    fromEnum WindowPositionCenterAlways = 3+    fromEnum WindowPositionCenterOnParent = 4+    fromEnum (AnotherWindowPosition k) = k++    toEnum 0 = WindowPositionNone+    toEnum 1 = WindowPositionCenter+    toEnum 2 = WindowPositionMouse+    toEnum 3 = WindowPositionCenterAlways+    toEnum 4 = WindowPositionCenterOnParent+    toEnum k = AnotherWindowPosition k++foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type :: +    IO GType++instance BoxedEnum WindowPosition where+    boxedEnumType _ = c_gtk_window_position_get_type++-- Enum WidgetHelpType++data WidgetHelpType = +      WidgetHelpTypeTooltip+    | WidgetHelpTypeWhatsThis+    | AnotherWidgetHelpType Int+    deriving (Show, Eq)++instance Enum WidgetHelpType where+    fromEnum WidgetHelpTypeTooltip = 0+    fromEnum WidgetHelpTypeWhatsThis = 1+    fromEnum (AnotherWidgetHelpType k) = k++    toEnum 0 = WidgetHelpTypeTooltip+    toEnum 1 = WidgetHelpTypeWhatsThis+    toEnum k = AnotherWidgetHelpType k++foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type :: +    IO GType++instance BoxedEnum WidgetHelpType where+    boxedEnumType _ = c_gtk_widget_help_type_get_type++-- Enum Unit++data Unit = +      UnitNone+    | UnitPoints+    | UnitInch+    | UnitMm+    | AnotherUnit Int+    deriving (Show, Eq)++instance Enum Unit where+    fromEnum UnitNone = 0+    fromEnum UnitPoints = 1+    fromEnum UnitInch = 2+    fromEnum UnitMm = 3+    fromEnum (AnotherUnit k) = k++    toEnum 0 = UnitNone+    toEnum 1 = UnitPoints+    toEnum 2 = UnitInch+    toEnum 3 = UnitMm+    toEnum k = AnotherUnit k++foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: +    IO GType++instance BoxedEnum Unit where+    boxedEnumType _ = c_gtk_unit_get_type++-- Enum TreeViewGridLines++data TreeViewGridLines = +      TreeViewGridLinesNone+    | TreeViewGridLinesHorizontal+    | TreeViewGridLinesVertical+    | TreeViewGridLinesBoth+    | AnotherTreeViewGridLines Int+    deriving (Show, Eq)++instance Enum TreeViewGridLines where+    fromEnum TreeViewGridLinesNone = 0+    fromEnum TreeViewGridLinesHorizontal = 1+    fromEnum TreeViewGridLinesVertical = 2+    fromEnum TreeViewGridLinesBoth = 3+    fromEnum (AnotherTreeViewGridLines k) = k++    toEnum 0 = TreeViewGridLinesNone+    toEnum 1 = TreeViewGridLinesHorizontal+    toEnum 2 = TreeViewGridLinesVertical+    toEnum 3 = TreeViewGridLinesBoth+    toEnum k = AnotherTreeViewGridLines k++foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type :: +    IO GType++instance BoxedEnum TreeViewGridLines where+    boxedEnumType _ = c_gtk_tree_view_grid_lines_get_type++-- Enum TreeViewDropPosition++data TreeViewDropPosition = +      TreeViewDropPositionBefore+    | TreeViewDropPositionAfter+    | TreeViewDropPositionIntoOrBefore+    | TreeViewDropPositionIntoOrAfter+    | AnotherTreeViewDropPosition Int+    deriving (Show, Eq)++instance Enum TreeViewDropPosition where+    fromEnum TreeViewDropPositionBefore = 0+    fromEnum TreeViewDropPositionAfter = 1+    fromEnum TreeViewDropPositionIntoOrBefore = 2+    fromEnum TreeViewDropPositionIntoOrAfter = 3+    fromEnum (AnotherTreeViewDropPosition k) = k++    toEnum 0 = TreeViewDropPositionBefore+    toEnum 1 = TreeViewDropPositionAfter+    toEnum 2 = TreeViewDropPositionIntoOrBefore+    toEnum 3 = TreeViewDropPositionIntoOrAfter+    toEnum k = AnotherTreeViewDropPosition k++foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type :: +    IO GType++instance BoxedEnum TreeViewDropPosition where+    boxedEnumType _ = c_gtk_tree_view_drop_position_get_type++-- Enum TreeViewColumnSizing++data TreeViewColumnSizing = +      TreeViewColumnSizingGrowOnly+    | TreeViewColumnSizingAutosize+    | TreeViewColumnSizingFixed+    | AnotherTreeViewColumnSizing Int+    deriving (Show, Eq)++instance Enum TreeViewColumnSizing where+    fromEnum TreeViewColumnSizingGrowOnly = 0+    fromEnum TreeViewColumnSizingAutosize = 1+    fromEnum TreeViewColumnSizingFixed = 2+    fromEnum (AnotherTreeViewColumnSizing k) = k++    toEnum 0 = TreeViewColumnSizingGrowOnly+    toEnum 1 = TreeViewColumnSizingAutosize+    toEnum 2 = TreeViewColumnSizingFixed+    toEnum k = AnotherTreeViewColumnSizing k++foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type :: +    IO GType++instance BoxedEnum TreeViewColumnSizing where+    boxedEnumType _ = c_gtk_tree_view_column_sizing_get_type++-- Enum ToolbarStyle++data ToolbarStyle = +      ToolbarStyleIcons+    | ToolbarStyleText+    | ToolbarStyleBoth+    | ToolbarStyleBothHoriz+    | AnotherToolbarStyle Int+    deriving (Show, Eq)++instance Enum ToolbarStyle where+    fromEnum ToolbarStyleIcons = 0+    fromEnum ToolbarStyleText = 1+    fromEnum ToolbarStyleBoth = 2+    fromEnum ToolbarStyleBothHoriz = 3+    fromEnum (AnotherToolbarStyle k) = k++    toEnum 0 = ToolbarStyleIcons+    toEnum 1 = ToolbarStyleText+    toEnum 2 = ToolbarStyleBoth+    toEnum 3 = ToolbarStyleBothHoriz+    toEnum k = AnotherToolbarStyle k++foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type :: +    IO GType++instance BoxedEnum ToolbarStyle where+    boxedEnumType _ = c_gtk_toolbar_style_get_type++-- Enum ToolbarSpaceStyle++data ToolbarSpaceStyle = +      ToolbarSpaceStyleEmpty+    | ToolbarSpaceStyleLine+    | AnotherToolbarSpaceStyle Int+    deriving (Show, Eq)++instance Enum ToolbarSpaceStyle where+    fromEnum ToolbarSpaceStyleEmpty = 0+    fromEnum ToolbarSpaceStyleLine = 1+    fromEnum (AnotherToolbarSpaceStyle k) = k++    toEnum 0 = ToolbarSpaceStyleEmpty+    toEnum 1 = ToolbarSpaceStyleLine+    toEnum k = AnotherToolbarSpaceStyle k++foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type :: +    IO GType++instance BoxedEnum ToolbarSpaceStyle where+    boxedEnumType _ = c_gtk_toolbar_space_style_get_type++-- Enum TextWindowType++data TextWindowType = +      TextWindowTypePrivate+    | TextWindowTypeWidget+    | TextWindowTypeText+    | TextWindowTypeLeft+    | TextWindowTypeRight+    | TextWindowTypeTop+    | TextWindowTypeBottom+    | AnotherTextWindowType Int+    deriving (Show, Eq)++instance Enum TextWindowType where+    fromEnum TextWindowTypePrivate = 0+    fromEnum TextWindowTypeWidget = 1+    fromEnum TextWindowTypeText = 2+    fromEnum TextWindowTypeLeft = 3+    fromEnum TextWindowTypeRight = 4+    fromEnum TextWindowTypeTop = 5+    fromEnum TextWindowTypeBottom = 6+    fromEnum (AnotherTextWindowType k) = k++    toEnum 0 = TextWindowTypePrivate+    toEnum 1 = TextWindowTypeWidget+    toEnum 2 = TextWindowTypeText+    toEnum 3 = TextWindowTypeLeft+    toEnum 4 = TextWindowTypeRight+    toEnum 5 = TextWindowTypeTop+    toEnum 6 = TextWindowTypeBottom+    toEnum k = AnotherTextWindowType k++foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: +    IO GType++instance BoxedEnum TextWindowType where+    boxedEnumType _ = c_gtk_text_window_type_get_type++-- Enum TextViewLayer++data TextViewLayer = +      TextViewLayerBelow+    | TextViewLayerAbove+    | AnotherTextViewLayer Int+    deriving (Show, Eq)++instance Enum TextViewLayer where+    fromEnum TextViewLayerBelow = 0+    fromEnum TextViewLayerAbove = 1+    fromEnum (AnotherTextViewLayer k) = k++    toEnum 0 = TextViewLayerBelow+    toEnum 1 = TextViewLayerAbove+    toEnum k = AnotherTextViewLayer k++foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: +    IO GType++instance BoxedEnum TextViewLayer where+    boxedEnumType _ = c_gtk_text_view_layer_get_type++-- Enum TextExtendSelection++data TextExtendSelection = +      TextExtendSelectionWord+    | TextExtendSelectionLine+    | AnotherTextExtendSelection Int+    deriving (Show, Eq)++instance Enum TextExtendSelection where+    fromEnum TextExtendSelectionWord = 0+    fromEnum TextExtendSelectionLine = 1+    fromEnum (AnotherTextExtendSelection k) = k++    toEnum 0 = TextExtendSelectionWord+    toEnum 1 = TextExtendSelectionLine+    toEnum k = AnotherTextExtendSelection k++foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: +    IO GType++instance BoxedEnum TextExtendSelection where+    boxedEnumType _ = c_gtk_text_extend_selection_get_type++-- Enum TextDirection++data TextDirection = +      TextDirectionNone+    | TextDirectionLtr+    | TextDirectionRtl+    | AnotherTextDirection Int+    deriving (Show, Eq)++instance Enum TextDirection where+    fromEnum TextDirectionNone = 0+    fromEnum TextDirectionLtr = 1+    fromEnum TextDirectionRtl = 2+    fromEnum (AnotherTextDirection k) = k++    toEnum 0 = TextDirectionNone+    toEnum 1 = TextDirectionLtr+    toEnum 2 = TextDirectionRtl+    toEnum k = AnotherTextDirection k++foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: +    IO GType++instance BoxedEnum TextDirection where+    boxedEnumType _ = c_gtk_text_direction_get_type++-- Enum TextBufferTargetInfo++data TextBufferTargetInfo = +      TextBufferTargetInfoBufferContents+    | TextBufferTargetInfoRichText+    | TextBufferTargetInfoText+    | AnotherTextBufferTargetInfo Int+    deriving (Show, Eq)++instance Enum TextBufferTargetInfo where+    fromEnum TextBufferTargetInfoBufferContents = -1+    fromEnum TextBufferTargetInfoRichText = -2+    fromEnum TextBufferTargetInfoText = -3+    fromEnum (AnotherTextBufferTargetInfo k) = k++    toEnum -3 = TextBufferTargetInfoText+    toEnum -2 = TextBufferTargetInfoRichText+    toEnum -1 = TextBufferTargetInfoBufferContents+    toEnum k = AnotherTextBufferTargetInfo k++foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type :: +    IO GType++instance BoxedEnum TextBufferTargetInfo where+    boxedEnumType _ = c_gtk_text_buffer_target_info_get_type++-- Enum StateType+{-# DEPRECATED StateType ["(Since version 3.14)","All APIs that are using this enumeration have been deprecated","    in favor of alternatives using #GtkStateFlags."]#-}+data StateType = +      StateTypeNormal+    | StateTypeActive+    | StateTypePrelight+    | StateTypeSelected+    | StateTypeInsensitive+    | StateTypeInconsistent+    | StateTypeFocused+    | AnotherStateType Int+    deriving (Show, Eq)++instance Enum StateType where+    fromEnum StateTypeNormal = 0+    fromEnum StateTypeActive = 1+    fromEnum StateTypePrelight = 2+    fromEnum StateTypeSelected = 3+    fromEnum StateTypeInsensitive = 4+    fromEnum StateTypeInconsistent = 5+    fromEnum StateTypeFocused = 6+    fromEnum (AnotherStateType k) = k++    toEnum 0 = StateTypeNormal+    toEnum 1 = StateTypeActive+    toEnum 2 = StateTypePrelight+    toEnum 3 = StateTypeSelected+    toEnum 4 = StateTypeInsensitive+    toEnum 5 = StateTypeInconsistent+    toEnum 6 = StateTypeFocused+    toEnum k = AnotherStateType k++foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type :: +    IO GType++instance BoxedEnum StateType where+    boxedEnumType _ = c_gtk_state_type_get_type++-- Enum StackTransitionType++data StackTransitionType = +      StackTransitionTypeNone+    | StackTransitionTypeCrossfade+    | StackTransitionTypeSlideRight+    | StackTransitionTypeSlideLeft+    | StackTransitionTypeSlideUp+    | StackTransitionTypeSlideDown+    | StackTransitionTypeSlideLeftRight+    | StackTransitionTypeSlideUpDown+    | StackTransitionTypeOverUp+    | StackTransitionTypeOverDown+    | StackTransitionTypeOverLeft+    | StackTransitionTypeOverRight+    | StackTransitionTypeUnderUp+    | StackTransitionTypeUnderDown+    | StackTransitionTypeUnderLeft+    | StackTransitionTypeUnderRight+    | StackTransitionTypeOverUpDown+    | StackTransitionTypeOverDownUp+    | StackTransitionTypeOverLeftRight+    | StackTransitionTypeOverRightLeft+    | AnotherStackTransitionType Int+    deriving (Show, Eq)++instance Enum StackTransitionType where+    fromEnum StackTransitionTypeNone = 0+    fromEnum StackTransitionTypeCrossfade = 1+    fromEnum StackTransitionTypeSlideRight = 2+    fromEnum StackTransitionTypeSlideLeft = 3+    fromEnum StackTransitionTypeSlideUp = 4+    fromEnum StackTransitionTypeSlideDown = 5+    fromEnum StackTransitionTypeSlideLeftRight = 6+    fromEnum StackTransitionTypeSlideUpDown = 7+    fromEnum StackTransitionTypeOverUp = 8+    fromEnum StackTransitionTypeOverDown = 9+    fromEnum StackTransitionTypeOverLeft = 10+    fromEnum StackTransitionTypeOverRight = 11+    fromEnum StackTransitionTypeUnderUp = 12+    fromEnum StackTransitionTypeUnderDown = 13+    fromEnum StackTransitionTypeUnderLeft = 14+    fromEnum StackTransitionTypeUnderRight = 15+    fromEnum StackTransitionTypeOverUpDown = 16+    fromEnum StackTransitionTypeOverDownUp = 17+    fromEnum StackTransitionTypeOverLeftRight = 18+    fromEnum StackTransitionTypeOverRightLeft = 19+    fromEnum (AnotherStackTransitionType k) = k++    toEnum 0 = StackTransitionTypeNone+    toEnum 1 = StackTransitionTypeCrossfade+    toEnum 2 = StackTransitionTypeSlideRight+    toEnum 3 = StackTransitionTypeSlideLeft+    toEnum 4 = StackTransitionTypeSlideUp+    toEnum 5 = StackTransitionTypeSlideDown+    toEnum 6 = StackTransitionTypeSlideLeftRight+    toEnum 7 = StackTransitionTypeSlideUpDown+    toEnum 8 = StackTransitionTypeOverUp+    toEnum 9 = StackTransitionTypeOverDown+    toEnum 10 = StackTransitionTypeOverLeft+    toEnum 11 = StackTransitionTypeOverRight+    toEnum 12 = StackTransitionTypeUnderUp+    toEnum 13 = StackTransitionTypeUnderDown+    toEnum 14 = StackTransitionTypeUnderLeft+    toEnum 15 = StackTransitionTypeUnderRight+    toEnum 16 = StackTransitionTypeOverUpDown+    toEnum 17 = StackTransitionTypeOverDownUp+    toEnum 18 = StackTransitionTypeOverLeftRight+    toEnum 19 = StackTransitionTypeOverRightLeft+    toEnum k = AnotherStackTransitionType k++foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: +    IO GType++instance BoxedEnum StackTransitionType where+    boxedEnumType _ = c_gtk_stack_transition_type_get_type++-- Enum SpinType++data SpinType = +      SpinTypeStepForward+    | SpinTypeStepBackward+    | SpinTypePageForward+    | SpinTypePageBackward+    | SpinTypeHome+    | SpinTypeEnd+    | SpinTypeUserDefined+    | AnotherSpinType Int+    deriving (Show, Eq)++instance Enum SpinType where+    fromEnum SpinTypeStepForward = 0+    fromEnum SpinTypeStepBackward = 1+    fromEnum SpinTypePageForward = 2+    fromEnum SpinTypePageBackward = 3+    fromEnum SpinTypeHome = 4+    fromEnum SpinTypeEnd = 5+    fromEnum SpinTypeUserDefined = 6+    fromEnum (AnotherSpinType k) = k++    toEnum 0 = SpinTypeStepForward+    toEnum 1 = SpinTypeStepBackward+    toEnum 2 = SpinTypePageForward+    toEnum 3 = SpinTypePageBackward+    toEnum 4 = SpinTypeHome+    toEnum 5 = SpinTypeEnd+    toEnum 6 = SpinTypeUserDefined+    toEnum k = AnotherSpinType k++foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: +    IO GType++instance BoxedEnum SpinType where+    boxedEnumType _ = c_gtk_spin_type_get_type++-- Enum SpinButtonUpdatePolicy++data SpinButtonUpdatePolicy = +      SpinButtonUpdatePolicyAlways+    | SpinButtonUpdatePolicyIfValid+    | AnotherSpinButtonUpdatePolicy Int+    deriving (Show, Eq)++instance Enum SpinButtonUpdatePolicy where+    fromEnum SpinButtonUpdatePolicyAlways = 0+    fromEnum SpinButtonUpdatePolicyIfValid = 1+    fromEnum (AnotherSpinButtonUpdatePolicy k) = k++    toEnum 0 = SpinButtonUpdatePolicyAlways+    toEnum 1 = SpinButtonUpdatePolicyIfValid+    toEnum k = AnotherSpinButtonUpdatePolicy k++foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type :: +    IO GType++instance BoxedEnum SpinButtonUpdatePolicy where+    boxedEnumType _ = c_gtk_spin_button_update_policy_get_type++-- Enum SortType++data SortType = +      SortTypeAscending+    | SortTypeDescending+    | AnotherSortType Int+    deriving (Show, Eq)++instance Enum SortType where+    fromEnum SortTypeAscending = 0+    fromEnum SortTypeDescending = 1+    fromEnum (AnotherSortType k) = k++    toEnum 0 = SortTypeAscending+    toEnum 1 = SortTypeDescending+    toEnum k = AnotherSortType k++foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: +    IO GType++instance BoxedEnum SortType where+    boxedEnumType _ = c_gtk_sort_type_get_type++-- Enum SizeRequestMode++data SizeRequestMode = +      SizeRequestModeHeightForWidth+    | SizeRequestModeWidthForHeight+    | SizeRequestModeConstantSize+    | AnotherSizeRequestMode Int+    deriving (Show, Eq)++instance Enum SizeRequestMode where+    fromEnum SizeRequestModeHeightForWidth = 0+    fromEnum SizeRequestModeWidthForHeight = 1+    fromEnum SizeRequestModeConstantSize = 2+    fromEnum (AnotherSizeRequestMode k) = k++    toEnum 0 = SizeRequestModeHeightForWidth+    toEnum 1 = SizeRequestModeWidthForHeight+    toEnum 2 = SizeRequestModeConstantSize+    toEnum k = AnotherSizeRequestMode k++foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: +    IO GType++instance BoxedEnum SizeRequestMode where+    boxedEnumType _ = c_gtk_size_request_mode_get_type++-- Enum SizeGroupMode++data SizeGroupMode = +      SizeGroupModeNone+    | SizeGroupModeHorizontal+    | SizeGroupModeVertical+    | SizeGroupModeBoth+    | AnotherSizeGroupMode Int+    deriving (Show, Eq)++instance Enum SizeGroupMode where+    fromEnum SizeGroupModeNone = 0+    fromEnum SizeGroupModeHorizontal = 1+    fromEnum SizeGroupModeVertical = 2+    fromEnum SizeGroupModeBoth = 3+    fromEnum (AnotherSizeGroupMode k) = k++    toEnum 0 = SizeGroupModeNone+    toEnum 1 = SizeGroupModeHorizontal+    toEnum 2 = SizeGroupModeVertical+    toEnum 3 = SizeGroupModeBoth+    toEnum k = AnotherSizeGroupMode k++foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: +    IO GType++instance BoxedEnum SizeGroupMode where+    boxedEnumType _ = c_gtk_size_group_mode_get_type++-- Enum ShadowType++data ShadowType = +      ShadowTypeNone+    | ShadowTypeIn+    | ShadowTypeOut+    | ShadowTypeEtchedIn+    | ShadowTypeEtchedOut+    | AnotherShadowType Int+    deriving (Show, Eq)++instance Enum ShadowType where+    fromEnum ShadowTypeNone = 0+    fromEnum ShadowTypeIn = 1+    fromEnum ShadowTypeOut = 2+    fromEnum ShadowTypeEtchedIn = 3+    fromEnum ShadowTypeEtchedOut = 4+    fromEnum (AnotherShadowType k) = k++    toEnum 0 = ShadowTypeNone+    toEnum 1 = ShadowTypeIn+    toEnum 2 = ShadowTypeOut+    toEnum 3 = ShadowTypeEtchedIn+    toEnum 4 = ShadowTypeEtchedOut+    toEnum k = AnotherShadowType k++foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type :: +    IO GType++instance BoxedEnum ShadowType where+    boxedEnumType _ = c_gtk_shadow_type_get_type++-- Enum SensitivityType++data SensitivityType = +      SensitivityTypeAuto+    | SensitivityTypeOn+    | SensitivityTypeOff+    | AnotherSensitivityType Int+    deriving (Show, Eq)++instance Enum SensitivityType where+    fromEnum SensitivityTypeAuto = 0+    fromEnum SensitivityTypeOn = 1+    fromEnum SensitivityTypeOff = 2+    fromEnum (AnotherSensitivityType k) = k++    toEnum 0 = SensitivityTypeAuto+    toEnum 1 = SensitivityTypeOn+    toEnum 2 = SensitivityTypeOff+    toEnum k = AnotherSensitivityType k++foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: +    IO GType++instance BoxedEnum SensitivityType where+    boxedEnumType _ = c_gtk_sensitivity_type_get_type++-- Enum SelectionMode++data SelectionMode = +      SelectionModeNone+    | SelectionModeSingle+    | SelectionModeBrowse+    | SelectionModeMultiple+    | AnotherSelectionMode Int+    deriving (Show, Eq)++instance Enum SelectionMode where+    fromEnum SelectionModeNone = 0+    fromEnum SelectionModeSingle = 1+    fromEnum SelectionModeBrowse = 2+    fromEnum SelectionModeMultiple = 3+    fromEnum (AnotherSelectionMode k) = k++    toEnum 0 = SelectionModeNone+    toEnum 1 = SelectionModeSingle+    toEnum 2 = SelectionModeBrowse+    toEnum 3 = SelectionModeMultiple+    toEnum k = AnotherSelectionMode k++foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: +    IO GType++instance BoxedEnum SelectionMode where+    boxedEnumType _ = c_gtk_selection_mode_get_type++-- Enum ScrollablePolicy++data ScrollablePolicy = +      ScrollablePolicyMinimum+    | ScrollablePolicyNatural+    | AnotherScrollablePolicy Int+    deriving (Show, Eq)++instance Enum ScrollablePolicy where+    fromEnum ScrollablePolicyMinimum = 0+    fromEnum ScrollablePolicyNatural = 1+    fromEnum (AnotherScrollablePolicy k) = k++    toEnum 0 = ScrollablePolicyMinimum+    toEnum 1 = ScrollablePolicyNatural+    toEnum k = AnotherScrollablePolicy k++foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: +    IO GType++instance BoxedEnum ScrollablePolicy where+    boxedEnumType _ = c_gtk_scrollable_policy_get_type++-- Enum ScrollType++data ScrollType = +      ScrollTypeNone+    | ScrollTypeJump+    | ScrollTypeStepBackward+    | ScrollTypeStepForward+    | ScrollTypePageBackward+    | ScrollTypePageForward+    | ScrollTypeStepUp+    | ScrollTypeStepDown+    | ScrollTypePageUp+    | ScrollTypePageDown+    | ScrollTypeStepLeft+    | ScrollTypeStepRight+    | ScrollTypePageLeft+    | ScrollTypePageRight+    | ScrollTypeStart+    | ScrollTypeEnd+    | AnotherScrollType Int+    deriving (Show, Eq)++instance Enum ScrollType where+    fromEnum ScrollTypeNone = 0+    fromEnum ScrollTypeJump = 1+    fromEnum ScrollTypeStepBackward = 2+    fromEnum ScrollTypeStepForward = 3+    fromEnum ScrollTypePageBackward = 4+    fromEnum ScrollTypePageForward = 5+    fromEnum ScrollTypeStepUp = 6+    fromEnum ScrollTypeStepDown = 7+    fromEnum ScrollTypePageUp = 8+    fromEnum ScrollTypePageDown = 9+    fromEnum ScrollTypeStepLeft = 10+    fromEnum ScrollTypeStepRight = 11+    fromEnum ScrollTypePageLeft = 12+    fromEnum ScrollTypePageRight = 13+    fromEnum ScrollTypeStart = 14+    fromEnum ScrollTypeEnd = 15+    fromEnum (AnotherScrollType k) = k++    toEnum 0 = ScrollTypeNone+    toEnum 1 = ScrollTypeJump+    toEnum 2 = ScrollTypeStepBackward+    toEnum 3 = ScrollTypeStepForward+    toEnum 4 = ScrollTypePageBackward+    toEnum 5 = ScrollTypePageForward+    toEnum 6 = ScrollTypeStepUp+    toEnum 7 = ScrollTypeStepDown+    toEnum 8 = ScrollTypePageUp+    toEnum 9 = ScrollTypePageDown+    toEnum 10 = ScrollTypeStepLeft+    toEnum 11 = ScrollTypeStepRight+    toEnum 12 = ScrollTypePageLeft+    toEnum 13 = ScrollTypePageRight+    toEnum 14 = ScrollTypeStart+    toEnum 15 = ScrollTypeEnd+    toEnum k = AnotherScrollType k++foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: +    IO GType++instance BoxedEnum ScrollType where+    boxedEnumType _ = c_gtk_scroll_type_get_type++-- Enum ScrollStep++data ScrollStep = +      ScrollStepSteps+    | ScrollStepPages+    | ScrollStepEnds+    | ScrollStepHorizontalSteps+    | ScrollStepHorizontalPages+    | ScrollStepHorizontalEnds+    | AnotherScrollStep Int+    deriving (Show, Eq)++instance Enum ScrollStep where+    fromEnum ScrollStepSteps = 0+    fromEnum ScrollStepPages = 1+    fromEnum ScrollStepEnds = 2+    fromEnum ScrollStepHorizontalSteps = 3+    fromEnum ScrollStepHorizontalPages = 4+    fromEnum ScrollStepHorizontalEnds = 5+    fromEnum (AnotherScrollStep k) = k++    toEnum 0 = ScrollStepSteps+    toEnum 1 = ScrollStepPages+    toEnum 2 = ScrollStepEnds+    toEnum 3 = ScrollStepHorizontalSteps+    toEnum 4 = ScrollStepHorizontalPages+    toEnum 5 = ScrollStepHorizontalEnds+    toEnum k = AnotherScrollStep k++foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: +    IO GType++instance BoxedEnum ScrollStep where+    boxedEnumType _ = c_gtk_scroll_step_get_type++-- Enum RevealerTransitionType++data RevealerTransitionType = +      RevealerTransitionTypeNone+    | RevealerTransitionTypeCrossfade+    | RevealerTransitionTypeSlideRight+    | RevealerTransitionTypeSlideLeft+    | RevealerTransitionTypeSlideUp+    | RevealerTransitionTypeSlideDown+    | AnotherRevealerTransitionType Int+    deriving (Show, Eq)++instance Enum RevealerTransitionType where+    fromEnum RevealerTransitionTypeNone = 0+    fromEnum RevealerTransitionTypeCrossfade = 1+    fromEnum RevealerTransitionTypeSlideRight = 2+    fromEnum RevealerTransitionTypeSlideLeft = 3+    fromEnum RevealerTransitionTypeSlideUp = 4+    fromEnum RevealerTransitionTypeSlideDown = 5+    fromEnum (AnotherRevealerTransitionType k) = k++    toEnum 0 = RevealerTransitionTypeNone+    toEnum 1 = RevealerTransitionTypeCrossfade+    toEnum 2 = RevealerTransitionTypeSlideRight+    toEnum 3 = RevealerTransitionTypeSlideLeft+    toEnum 4 = RevealerTransitionTypeSlideUp+    toEnum 5 = RevealerTransitionTypeSlideDown+    toEnum k = AnotherRevealerTransitionType k++foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: +    IO GType++instance BoxedEnum RevealerTransitionType where+    boxedEnumType _ = c_gtk_revealer_transition_type_get_type++-- Enum ResponseType++data ResponseType = +      ResponseTypeNone+    | ResponseTypeReject+    | ResponseTypeAccept+    | ResponseTypeDeleteEvent+    | ResponseTypeOk+    | ResponseTypeCancel+    | ResponseTypeClose+    | ResponseTypeYes+    | ResponseTypeNo+    | ResponseTypeApply+    | ResponseTypeHelp+    | AnotherResponseType Int+    deriving (Show, Eq)++instance Enum ResponseType where+    fromEnum ResponseTypeNone = -1+    fromEnum ResponseTypeReject = -2+    fromEnum ResponseTypeAccept = -3+    fromEnum ResponseTypeDeleteEvent = -4+    fromEnum ResponseTypeOk = -5+    fromEnum ResponseTypeCancel = -6+    fromEnum ResponseTypeClose = -7+    fromEnum ResponseTypeYes = -8+    fromEnum ResponseTypeNo = -9+    fromEnum ResponseTypeApply = -10+    fromEnum ResponseTypeHelp = -11+    fromEnum (AnotherResponseType k) = k++    toEnum -11 = ResponseTypeHelp+    toEnum -10 = ResponseTypeApply+    toEnum -9 = ResponseTypeNo+    toEnum -8 = ResponseTypeYes+    toEnum -7 = ResponseTypeClose+    toEnum -6 = ResponseTypeCancel+    toEnum -5 = ResponseTypeOk+    toEnum -4 = ResponseTypeDeleteEvent+    toEnum -3 = ResponseTypeAccept+    toEnum -2 = ResponseTypeReject+    toEnum -1 = ResponseTypeNone+    toEnum k = AnotherResponseType k++foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: +    IO GType++instance BoxedEnum ResponseType where+    boxedEnumType _ = c_gtk_response_type_get_type++-- Enum ResizeMode++data ResizeMode = +      ResizeModeParent+    | ResizeModeQueue+    | ResizeModeImmediate+    | AnotherResizeMode Int+    deriving (Show, Eq)++instance Enum ResizeMode where+    fromEnum ResizeModeParent = 0+    fromEnum ResizeModeQueue = 1+    fromEnum ResizeModeImmediate = 2+    fromEnum (AnotherResizeMode k) = k++    toEnum 0 = ResizeModeParent+    toEnum 1 = ResizeModeQueue+    toEnum 2 = ResizeModeImmediate+    toEnum k = AnotherResizeMode k++foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type :: +    IO GType++instance BoxedEnum ResizeMode where+    boxedEnumType _ = c_gtk_resize_mode_get_type++-- Enum ReliefStyle++data ReliefStyle = +      ReliefStyleNormal+    | ReliefStyleHalf+    | ReliefStyleNone+    | AnotherReliefStyle Int+    deriving (Show, Eq)++instance Enum ReliefStyle where+    fromEnum ReliefStyleNormal = 0+    fromEnum ReliefStyleHalf = 1+    fromEnum ReliefStyleNone = 2+    fromEnum (AnotherReliefStyle k) = k++    toEnum 0 = ReliefStyleNormal+    toEnum 1 = ReliefStyleHalf+    toEnum 2 = ReliefStyleNone+    toEnum k = AnotherReliefStyle k++foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type :: +    IO GType++instance BoxedEnum ReliefStyle where+    boxedEnumType _ = c_gtk_relief_style_get_type++-- Enum RecentSortType++data RecentSortType = +      RecentSortTypeNone+    | RecentSortTypeMru+    | RecentSortTypeLru+    | RecentSortTypeCustom+    | AnotherRecentSortType Int+    deriving (Show, Eq)++instance Enum RecentSortType where+    fromEnum RecentSortTypeNone = 0+    fromEnum RecentSortTypeMru = 1+    fromEnum RecentSortTypeLru = 2+    fromEnum RecentSortTypeCustom = 3+    fromEnum (AnotherRecentSortType k) = k++    toEnum 0 = RecentSortTypeNone+    toEnum 1 = RecentSortTypeMru+    toEnum 2 = RecentSortTypeLru+    toEnum 3 = RecentSortTypeCustom+    toEnum k = AnotherRecentSortType k++foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type :: +    IO GType++instance BoxedEnum RecentSortType where+    boxedEnumType _ = c_gtk_recent_sort_type_get_type++-- Enum RecentManagerError++data RecentManagerError = +      RecentManagerErrorNotFound+    | RecentManagerErrorInvalidUri+    | RecentManagerErrorInvalidEncoding+    | RecentManagerErrorNotRegistered+    | RecentManagerErrorRead+    | RecentManagerErrorWrite+    | RecentManagerErrorUnknown+    | AnotherRecentManagerError Int+    deriving (Show, Eq)++instance Enum RecentManagerError where+    fromEnum RecentManagerErrorNotFound = 0+    fromEnum RecentManagerErrorInvalidUri = 1+    fromEnum RecentManagerErrorInvalidEncoding = 2+    fromEnum RecentManagerErrorNotRegistered = 3+    fromEnum RecentManagerErrorRead = 4+    fromEnum RecentManagerErrorWrite = 5+    fromEnum RecentManagerErrorUnknown = 6+    fromEnum (AnotherRecentManagerError k) = k++    toEnum 0 = RecentManagerErrorNotFound+    toEnum 1 = RecentManagerErrorInvalidUri+    toEnum 2 = RecentManagerErrorInvalidEncoding+    toEnum 3 = RecentManagerErrorNotRegistered+    toEnum 4 = RecentManagerErrorRead+    toEnum 5 = RecentManagerErrorWrite+    toEnum 6 = RecentManagerErrorUnknown+    toEnum k = AnotherRecentManagerError k++instance GErrorClass RecentManagerError where+    gerrorClassDomain _ = "gtk-recent-manager-error-quark"++catchRecentManagerError ::+    IO a ->+    (RecentManagerError -> GErrorMessage -> IO a) ->+    IO a+catchRecentManagerError = catchGErrorJustDomain++handleRecentManagerError ::+    (RecentManagerError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleRecentManagerError = handleGErrorJustDomain++foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: +    IO GType++instance BoxedEnum RecentManagerError where+    boxedEnumType _ = c_gtk_recent_manager_error_get_type++-- Enum RecentChooserError++data RecentChooserError = +      RecentChooserErrorNotFound+    | RecentChooserErrorInvalidUri+    | AnotherRecentChooserError Int+    deriving (Show, Eq)++instance Enum RecentChooserError where+    fromEnum RecentChooserErrorNotFound = 0+    fromEnum RecentChooserErrorInvalidUri = 1+    fromEnum (AnotherRecentChooserError k) = k++    toEnum 0 = RecentChooserErrorNotFound+    toEnum 1 = RecentChooserErrorInvalidUri+    toEnum k = AnotherRecentChooserError k++instance GErrorClass RecentChooserError where+    gerrorClassDomain _ = "gtk-recent-chooser-error-quark"++catchRecentChooserError ::+    IO a ->+    (RecentChooserError -> GErrorMessage -> IO a) ->+    IO a+catchRecentChooserError = catchGErrorJustDomain++handleRecentChooserError ::+    (RecentChooserError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleRecentChooserError = handleGErrorJustDomain++foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type :: +    IO GType++instance BoxedEnum RecentChooserError where+    boxedEnumType _ = c_gtk_recent_chooser_error_get_type++-- Enum RcTokenType+{-# DEPRECATED RcTokenType ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+data RcTokenType = +      RcTokenTypeInvalid+    | RcTokenTypeInclude+    | RcTokenTypeNormal+    | RcTokenTypeActive+    | RcTokenTypePrelight+    | RcTokenTypeSelected+    | RcTokenTypeInsensitive+    | RcTokenTypeFg+    | RcTokenTypeBg+    | RcTokenTypeText+    | RcTokenTypeBase+    | RcTokenTypeXthickness+    | RcTokenTypeYthickness+    | RcTokenTypeFont+    | RcTokenTypeFontset+    | RcTokenTypeFontName+    | RcTokenTypeBgPixmap+    | RcTokenTypePixmapPath+    | RcTokenTypeStyle+    | RcTokenTypeBinding+    | RcTokenTypeBind+    | RcTokenTypeWidget+    | RcTokenTypeWidgetClass+    | RcTokenTypeClass+    | RcTokenTypeLowest+    | RcTokenTypeGtk+    | RcTokenTypeApplication+    | RcTokenTypeTheme+    | RcTokenTypeRc+    | RcTokenTypeHighest+    | RcTokenTypeEngine+    | RcTokenTypeModulePath+    | RcTokenTypeImModulePath+    | RcTokenTypeImModuleFile+    | RcTokenTypeStock+    | RcTokenTypeLtr+    | RcTokenTypeRtl+    | RcTokenTypeColor+    | RcTokenTypeUnbind+    | RcTokenTypeLast+    | AnotherRcTokenType Int+    deriving (Show, Eq)++instance Enum RcTokenType where+    fromEnum RcTokenTypeInvalid = 270+    fromEnum RcTokenTypeInclude = 271+    fromEnum RcTokenTypeNormal = 272+    fromEnum RcTokenTypeActive = 273+    fromEnum RcTokenTypePrelight = 274+    fromEnum RcTokenTypeSelected = 275+    fromEnum RcTokenTypeInsensitive = 276+    fromEnum RcTokenTypeFg = 277+    fromEnum RcTokenTypeBg = 278+    fromEnum RcTokenTypeText = 279+    fromEnum RcTokenTypeBase = 280+    fromEnum RcTokenTypeXthickness = 281+    fromEnum RcTokenTypeYthickness = 282+    fromEnum RcTokenTypeFont = 283+    fromEnum RcTokenTypeFontset = 284+    fromEnum RcTokenTypeFontName = 285+    fromEnum RcTokenTypeBgPixmap = 286+    fromEnum RcTokenTypePixmapPath = 287+    fromEnum RcTokenTypeStyle = 288+    fromEnum RcTokenTypeBinding = 289+    fromEnum RcTokenTypeBind = 290+    fromEnum RcTokenTypeWidget = 291+    fromEnum RcTokenTypeWidgetClass = 292+    fromEnum RcTokenTypeClass = 293+    fromEnum RcTokenTypeLowest = 294+    fromEnum RcTokenTypeGtk = 295+    fromEnum RcTokenTypeApplication = 296+    fromEnum RcTokenTypeTheme = 297+    fromEnum RcTokenTypeRc = 298+    fromEnum RcTokenTypeHighest = 299+    fromEnum RcTokenTypeEngine = 300+    fromEnum RcTokenTypeModulePath = 301+    fromEnum RcTokenTypeImModulePath = 302+    fromEnum RcTokenTypeImModuleFile = 303+    fromEnum RcTokenTypeStock = 304+    fromEnum RcTokenTypeLtr = 305+    fromEnum RcTokenTypeRtl = 306+    fromEnum RcTokenTypeColor = 307+    fromEnum RcTokenTypeUnbind = 308+    fromEnum RcTokenTypeLast = 309+    fromEnum (AnotherRcTokenType k) = k++    toEnum 270 = RcTokenTypeInvalid+    toEnum 271 = RcTokenTypeInclude+    toEnum 272 = RcTokenTypeNormal+    toEnum 273 = RcTokenTypeActive+    toEnum 274 = RcTokenTypePrelight+    toEnum 275 = RcTokenTypeSelected+    toEnum 276 = RcTokenTypeInsensitive+    toEnum 277 = RcTokenTypeFg+    toEnum 278 = RcTokenTypeBg+    toEnum 279 = RcTokenTypeText+    toEnum 280 = RcTokenTypeBase+    toEnum 281 = RcTokenTypeXthickness+    toEnum 282 = RcTokenTypeYthickness+    toEnum 283 = RcTokenTypeFont+    toEnum 284 = RcTokenTypeFontset+    toEnum 285 = RcTokenTypeFontName+    toEnum 286 = RcTokenTypeBgPixmap+    toEnum 287 = RcTokenTypePixmapPath+    toEnum 288 = RcTokenTypeStyle+    toEnum 289 = RcTokenTypeBinding+    toEnum 290 = RcTokenTypeBind+    toEnum 291 = RcTokenTypeWidget+    toEnum 292 = RcTokenTypeWidgetClass+    toEnum 293 = RcTokenTypeClass+    toEnum 294 = RcTokenTypeLowest+    toEnum 295 = RcTokenTypeGtk+    toEnum 296 = RcTokenTypeApplication+    toEnum 297 = RcTokenTypeTheme+    toEnum 298 = RcTokenTypeRc+    toEnum 299 = RcTokenTypeHighest+    toEnum 300 = RcTokenTypeEngine+    toEnum 301 = RcTokenTypeModulePath+    toEnum 302 = RcTokenTypeImModulePath+    toEnum 303 = RcTokenTypeImModuleFile+    toEnum 304 = RcTokenTypeStock+    toEnum 305 = RcTokenTypeLtr+    toEnum 306 = RcTokenTypeRtl+    toEnum 307 = RcTokenTypeColor+    toEnum 308 = RcTokenTypeUnbind+    toEnum 309 = RcTokenTypeLast+    toEnum k = AnotherRcTokenType k++foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type :: +    IO GType++instance BoxedEnum RcTokenType where+    boxedEnumType _ = c_gtk_rc_token_type_get_type++-- Enum PropagationPhase++data PropagationPhase = +      PropagationPhaseNone+    | PropagationPhaseCapture+    | PropagationPhaseBubble+    | PropagationPhaseTarget+    | AnotherPropagationPhase Int+    deriving (Show, Eq)++instance Enum PropagationPhase where+    fromEnum PropagationPhaseNone = 0+    fromEnum PropagationPhaseCapture = 1+    fromEnum PropagationPhaseBubble = 2+    fromEnum PropagationPhaseTarget = 3+    fromEnum (AnotherPropagationPhase k) = k++    toEnum 0 = PropagationPhaseNone+    toEnum 1 = PropagationPhaseCapture+    toEnum 2 = PropagationPhaseBubble+    toEnum 3 = PropagationPhaseTarget+    toEnum k = AnotherPropagationPhase k++foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: +    IO GType++instance BoxedEnum PropagationPhase where+    boxedEnumType _ = c_gtk_propagation_phase_get_type++-- Enum PrintStatus++data PrintStatus = +      PrintStatusInitial+    | PrintStatusPreparing+    | PrintStatusGeneratingData+    | PrintStatusSendingData+    | PrintStatusPending+    | PrintStatusPendingIssue+    | PrintStatusPrinting+    | PrintStatusFinished+    | PrintStatusFinishedAborted+    | AnotherPrintStatus Int+    deriving (Show, Eq)++instance Enum PrintStatus where+    fromEnum PrintStatusInitial = 0+    fromEnum PrintStatusPreparing = 1+    fromEnum PrintStatusGeneratingData = 2+    fromEnum PrintStatusSendingData = 3+    fromEnum PrintStatusPending = 4+    fromEnum PrintStatusPendingIssue = 5+    fromEnum PrintStatusPrinting = 6+    fromEnum PrintStatusFinished = 7+    fromEnum PrintStatusFinishedAborted = 8+    fromEnum (AnotherPrintStatus k) = k++    toEnum 0 = PrintStatusInitial+    toEnum 1 = PrintStatusPreparing+    toEnum 2 = PrintStatusGeneratingData+    toEnum 3 = PrintStatusSendingData+    toEnum 4 = PrintStatusPending+    toEnum 5 = PrintStatusPendingIssue+    toEnum 6 = PrintStatusPrinting+    toEnum 7 = PrintStatusFinished+    toEnum 8 = PrintStatusFinishedAborted+    toEnum k = AnotherPrintStatus k++foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: +    IO GType++instance BoxedEnum PrintStatus where+    boxedEnumType _ = c_gtk_print_status_get_type++-- Enum PrintQuality++data PrintQuality = +      PrintQualityLow+    | PrintQualityNormal+    | PrintQualityHigh+    | PrintQualityDraft+    | AnotherPrintQuality Int+    deriving (Show, Eq)++instance Enum PrintQuality where+    fromEnum PrintQualityLow = 0+    fromEnum PrintQualityNormal = 1+    fromEnum PrintQualityHigh = 2+    fromEnum PrintQualityDraft = 3+    fromEnum (AnotherPrintQuality k) = k++    toEnum 0 = PrintQualityLow+    toEnum 1 = PrintQualityNormal+    toEnum 2 = PrintQualityHigh+    toEnum 3 = PrintQualityDraft+    toEnum k = AnotherPrintQuality k++foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: +    IO GType++instance BoxedEnum PrintQuality where+    boxedEnumType _ = c_gtk_print_quality_get_type++-- Enum PrintPages++data PrintPages = +      PrintPagesAll+    | PrintPagesCurrent+    | PrintPagesRanges+    | PrintPagesSelection+    | AnotherPrintPages Int+    deriving (Show, Eq)++instance Enum PrintPages where+    fromEnum PrintPagesAll = 0+    fromEnum PrintPagesCurrent = 1+    fromEnum PrintPagesRanges = 2+    fromEnum PrintPagesSelection = 3+    fromEnum (AnotherPrintPages k) = k++    toEnum 0 = PrintPagesAll+    toEnum 1 = PrintPagesCurrent+    toEnum 2 = PrintPagesRanges+    toEnum 3 = PrintPagesSelection+    toEnum k = AnotherPrintPages k++foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: +    IO GType++instance BoxedEnum PrintPages where+    boxedEnumType _ = c_gtk_print_pages_get_type++-- Enum PrintOperationResult++data PrintOperationResult = +      PrintOperationResultError+    | PrintOperationResultApply+    | PrintOperationResultCancel+    | PrintOperationResultInProgress+    | AnotherPrintOperationResult Int+    deriving (Show, Eq)++instance Enum PrintOperationResult where+    fromEnum PrintOperationResultError = 0+    fromEnum PrintOperationResultApply = 1+    fromEnum PrintOperationResultCancel = 2+    fromEnum PrintOperationResultInProgress = 3+    fromEnum (AnotherPrintOperationResult k) = k++    toEnum 0 = PrintOperationResultError+    toEnum 1 = PrintOperationResultApply+    toEnum 2 = PrintOperationResultCancel+    toEnum 3 = PrintOperationResultInProgress+    toEnum k = AnotherPrintOperationResult k++foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: +    IO GType++instance BoxedEnum PrintOperationResult where+    boxedEnumType _ = c_gtk_print_operation_result_get_type++-- Enum PrintOperationAction++data PrintOperationAction = +      PrintOperationActionPrintDialog+    | PrintOperationActionPrint+    | PrintOperationActionPreview+    | PrintOperationActionExport+    | AnotherPrintOperationAction Int+    deriving (Show, Eq)++instance Enum PrintOperationAction where+    fromEnum PrintOperationActionPrintDialog = 0+    fromEnum PrintOperationActionPrint = 1+    fromEnum PrintOperationActionPreview = 2+    fromEnum PrintOperationActionExport = 3+    fromEnum (AnotherPrintOperationAction k) = k++    toEnum 0 = PrintOperationActionPrintDialog+    toEnum 1 = PrintOperationActionPrint+    toEnum 2 = PrintOperationActionPreview+    toEnum 3 = PrintOperationActionExport+    toEnum k = AnotherPrintOperationAction k++foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: +    IO GType++instance BoxedEnum PrintOperationAction where+    boxedEnumType _ = c_gtk_print_operation_action_get_type++-- Enum PrintError++data PrintError = +      PrintErrorGeneral+    | PrintErrorInternalError+    | PrintErrorNomem+    | PrintErrorInvalidFile+    | AnotherPrintError Int+    deriving (Show, Eq)++instance Enum PrintError where+    fromEnum PrintErrorGeneral = 0+    fromEnum PrintErrorInternalError = 1+    fromEnum PrintErrorNomem = 2+    fromEnum PrintErrorInvalidFile = 3+    fromEnum (AnotherPrintError k) = k++    toEnum 0 = PrintErrorGeneral+    toEnum 1 = PrintErrorInternalError+    toEnum 2 = PrintErrorNomem+    toEnum 3 = PrintErrorInvalidFile+    toEnum k = AnotherPrintError k++instance GErrorClass PrintError where+    gerrorClassDomain _ = "gtk-print-error-quark"++catchPrintError ::+    IO a ->+    (PrintError -> GErrorMessage -> IO a) ->+    IO a+catchPrintError = catchGErrorJustDomain++handlePrintError ::+    (PrintError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handlePrintError = handleGErrorJustDomain++foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: +    IO GType++instance BoxedEnum PrintError where+    boxedEnumType _ = c_gtk_print_error_get_type++-- Enum PrintDuplex++data PrintDuplex = +      PrintDuplexSimplex+    | PrintDuplexHorizontal+    | PrintDuplexVertical+    | AnotherPrintDuplex Int+    deriving (Show, Eq)++instance Enum PrintDuplex where+    fromEnum PrintDuplexSimplex = 0+    fromEnum PrintDuplexHorizontal = 1+    fromEnum PrintDuplexVertical = 2+    fromEnum (AnotherPrintDuplex k) = k++    toEnum 0 = PrintDuplexSimplex+    toEnum 1 = PrintDuplexHorizontal+    toEnum 2 = PrintDuplexVertical+    toEnum k = AnotherPrintDuplex k++foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: +    IO GType++instance BoxedEnum PrintDuplex where+    boxedEnumType _ = c_gtk_print_duplex_get_type++-- Enum PositionType++data PositionType = +      PositionTypeLeft+    | PositionTypeRight+    | PositionTypeTop+    | PositionTypeBottom+    | AnotherPositionType Int+    deriving (Show, Eq)++instance Enum PositionType where+    fromEnum PositionTypeLeft = 0+    fromEnum PositionTypeRight = 1+    fromEnum PositionTypeTop = 2+    fromEnum PositionTypeBottom = 3+    fromEnum (AnotherPositionType k) = k++    toEnum 0 = PositionTypeLeft+    toEnum 1 = PositionTypeRight+    toEnum 2 = PositionTypeTop+    toEnum 3 = PositionTypeBottom+    toEnum k = AnotherPositionType k++foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: +    IO GType++instance BoxedEnum PositionType where+    boxedEnumType _ = c_gtk_position_type_get_type++-- Enum PolicyType++data PolicyType = +      PolicyTypeAlways+    | PolicyTypeAutomatic+    | PolicyTypeNever+    | PolicyTypeExternal+    | AnotherPolicyType Int+    deriving (Show, Eq)++instance Enum PolicyType where+    fromEnum PolicyTypeAlways = 0+    fromEnum PolicyTypeAutomatic = 1+    fromEnum PolicyTypeNever = 2+    fromEnum PolicyTypeExternal = 3+    fromEnum (AnotherPolicyType k) = k++    toEnum 0 = PolicyTypeAlways+    toEnum 1 = PolicyTypeAutomatic+    toEnum 2 = PolicyTypeNever+    toEnum 3 = PolicyTypeExternal+    toEnum k = AnotherPolicyType k++foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: +    IO GType++instance BoxedEnum PolicyType where+    boxedEnumType _ = c_gtk_policy_type_get_type++-- Enum PathType+{-# DEPRECATED PathType ["(Since version 3.0)"]#-}+data PathType = +      PathTypeWidget+    | PathTypeWidgetClass+    | PathTypeClass+    | AnotherPathType Int+    deriving (Show, Eq)++instance Enum PathType where+    fromEnum PathTypeWidget = 0+    fromEnum PathTypeWidgetClass = 1+    fromEnum PathTypeClass = 2+    fromEnum (AnotherPathType k) = k++    toEnum 0 = PathTypeWidget+    toEnum 1 = PathTypeWidgetClass+    toEnum 2 = PathTypeClass+    toEnum k = AnotherPathType k++foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type :: +    IO GType++instance BoxedEnum PathType where+    boxedEnumType _ = c_gtk_path_type_get_type++-- Enum PathPriorityType+{-# DEPRECATED PathPriorityType ["(Since version 3.0)"]#-}+data PathPriorityType = +      PathPriorityTypeLowest+    | PathPriorityTypeGtk+    | PathPriorityTypeApplication+    | PathPriorityTypeTheme+    | PathPriorityTypeRc+    | PathPriorityTypeHighest+    | AnotherPathPriorityType Int+    deriving (Show, Eq)++instance Enum PathPriorityType where+    fromEnum PathPriorityTypeLowest = 0+    fromEnum PathPriorityTypeGtk = 4+    fromEnum PathPriorityTypeApplication = 8+    fromEnum PathPriorityTypeTheme = 10+    fromEnum PathPriorityTypeRc = 12+    fromEnum PathPriorityTypeHighest = 15+    fromEnum (AnotherPathPriorityType k) = k++    toEnum 0 = PathPriorityTypeLowest+    toEnum 4 = PathPriorityTypeGtk+    toEnum 8 = PathPriorityTypeApplication+    toEnum 10 = PathPriorityTypeTheme+    toEnum 12 = PathPriorityTypeRc+    toEnum 15 = PathPriorityTypeHighest+    toEnum k = AnotherPathPriorityType k++foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type :: +    IO GType++instance BoxedEnum PathPriorityType where+    boxedEnumType _ = c_gtk_path_priority_type_get_type++-- Enum PanDirection++data PanDirection = +      PanDirectionLeft+    | PanDirectionRight+    | PanDirectionUp+    | PanDirectionDown+    | AnotherPanDirection Int+    deriving (Show, Eq)++instance Enum PanDirection where+    fromEnum PanDirectionLeft = 0+    fromEnum PanDirectionRight = 1+    fromEnum PanDirectionUp = 2+    fromEnum PanDirectionDown = 3+    fromEnum (AnotherPanDirection k) = k++    toEnum 0 = PanDirectionLeft+    toEnum 1 = PanDirectionRight+    toEnum 2 = PanDirectionUp+    toEnum 3 = PanDirectionDown+    toEnum k = AnotherPanDirection k++foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: +    IO GType++instance BoxedEnum PanDirection where+    boxedEnumType _ = c_gtk_pan_direction_get_type++-- Enum PageSet++data PageSet = +      PageSetAll+    | PageSetEven+    | PageSetOdd+    | AnotherPageSet Int+    deriving (Show, Eq)++instance Enum PageSet where+    fromEnum PageSetAll = 0+    fromEnum PageSetEven = 1+    fromEnum PageSetOdd = 2+    fromEnum (AnotherPageSet k) = k++    toEnum 0 = PageSetAll+    toEnum 1 = PageSetEven+    toEnum 2 = PageSetOdd+    toEnum k = AnotherPageSet k++foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: +    IO GType++instance BoxedEnum PageSet where+    boxedEnumType _ = c_gtk_page_set_get_type++-- Enum PageOrientation++data PageOrientation = +      PageOrientationPortrait+    | PageOrientationLandscape+    | PageOrientationReversePortrait+    | PageOrientationReverseLandscape+    | AnotherPageOrientation Int+    deriving (Show, Eq)++instance Enum PageOrientation where+    fromEnum PageOrientationPortrait = 0+    fromEnum PageOrientationLandscape = 1+    fromEnum PageOrientationReversePortrait = 2+    fromEnum PageOrientationReverseLandscape = 3+    fromEnum (AnotherPageOrientation k) = k++    toEnum 0 = PageOrientationPortrait+    toEnum 1 = PageOrientationLandscape+    toEnum 2 = PageOrientationReversePortrait+    toEnum 3 = PageOrientationReverseLandscape+    toEnum k = AnotherPageOrientation k++foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: +    IO GType++instance BoxedEnum PageOrientation where+    boxedEnumType _ = c_gtk_page_orientation_get_type++-- Enum PackType++data PackType = +      PackTypeStart+    | PackTypeEnd+    | AnotherPackType Int+    deriving (Show, Eq)++instance Enum PackType where+    fromEnum PackTypeStart = 0+    fromEnum PackTypeEnd = 1+    fromEnum (AnotherPackType k) = k++    toEnum 0 = PackTypeStart+    toEnum 1 = PackTypeEnd+    toEnum k = AnotherPackType k++foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: +    IO GType++instance BoxedEnum PackType where+    boxedEnumType _ = c_gtk_pack_type_get_type++-- Enum PackDirection++data PackDirection = +      PackDirectionLtr+    | PackDirectionRtl+    | PackDirectionTtb+    | PackDirectionBtt+    | AnotherPackDirection Int+    deriving (Show, Eq)++instance Enum PackDirection where+    fromEnum PackDirectionLtr = 0+    fromEnum PackDirectionRtl = 1+    fromEnum PackDirectionTtb = 2+    fromEnum PackDirectionBtt = 3+    fromEnum (AnotherPackDirection k) = k++    toEnum 0 = PackDirectionLtr+    toEnum 1 = PackDirectionRtl+    toEnum 2 = PackDirectionTtb+    toEnum 3 = PackDirectionBtt+    toEnum k = AnotherPackDirection k++foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type :: +    IO GType++instance BoxedEnum PackDirection where+    boxedEnumType _ = c_gtk_pack_direction_get_type++-- Enum Orientation++data Orientation = +      OrientationHorizontal+    | OrientationVertical+    | AnotherOrientation Int+    deriving (Show, Eq)++instance Enum Orientation where+    fromEnum OrientationHorizontal = 0+    fromEnum OrientationVertical = 1+    fromEnum (AnotherOrientation k) = k++    toEnum 0 = OrientationHorizontal+    toEnum 1 = OrientationVertical+    toEnum k = AnotherOrientation k++foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: +    IO GType++instance BoxedEnum Orientation where+    boxedEnumType _ = c_gtk_orientation_get_type++-- Enum NumberUpLayout++data NumberUpLayout = +      NumberUpLayoutLrtb+    | NumberUpLayoutLrbt+    | NumberUpLayoutRltb+    | NumberUpLayoutRlbt+    | NumberUpLayoutTblr+    | NumberUpLayoutTbrl+    | NumberUpLayoutBtlr+    | NumberUpLayoutBtrl+    | AnotherNumberUpLayout Int+    deriving (Show, Eq)++instance Enum NumberUpLayout where+    fromEnum NumberUpLayoutLrtb = 0+    fromEnum NumberUpLayoutLrbt = 1+    fromEnum NumberUpLayoutRltb = 2+    fromEnum NumberUpLayoutRlbt = 3+    fromEnum NumberUpLayoutTblr = 4+    fromEnum NumberUpLayoutTbrl = 5+    fromEnum NumberUpLayoutBtlr = 6+    fromEnum NumberUpLayoutBtrl = 7+    fromEnum (AnotherNumberUpLayout k) = k++    toEnum 0 = NumberUpLayoutLrtb+    toEnum 1 = NumberUpLayoutLrbt+    toEnum 2 = NumberUpLayoutRltb+    toEnum 3 = NumberUpLayoutRlbt+    toEnum 4 = NumberUpLayoutTblr+    toEnum 5 = NumberUpLayoutTbrl+    toEnum 6 = NumberUpLayoutBtlr+    toEnum 7 = NumberUpLayoutBtrl+    toEnum k = AnotherNumberUpLayout k++foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type :: +    IO GType++instance BoxedEnum NumberUpLayout where+    boxedEnumType _ = c_gtk_number_up_layout_get_type++-- Enum NotebookTab++data NotebookTab = +      NotebookTabFirst+    | NotebookTabLast+    | AnotherNotebookTab Int+    deriving (Show, Eq)++instance Enum NotebookTab where+    fromEnum NotebookTabFirst = 0+    fromEnum NotebookTabLast = 1+    fromEnum (AnotherNotebookTab k) = k++    toEnum 0 = NotebookTabFirst+    toEnum 1 = NotebookTabLast+    toEnum k = AnotherNotebookTab k++foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type :: +    IO GType++instance BoxedEnum NotebookTab where+    boxedEnumType _ = c_gtk_notebook_tab_get_type++-- Enum MovementStep++data MovementStep = +      MovementStepLogicalPositions+    | MovementStepVisualPositions+    | MovementStepWords+    | MovementStepDisplayLines+    | MovementStepDisplayLineEnds+    | MovementStepParagraphs+    | MovementStepParagraphEnds+    | MovementStepPages+    | MovementStepBufferEnds+    | MovementStepHorizontalPages+    | AnotherMovementStep Int+    deriving (Show, Eq)++instance Enum MovementStep where+    fromEnum MovementStepLogicalPositions = 0+    fromEnum MovementStepVisualPositions = 1+    fromEnum MovementStepWords = 2+    fromEnum MovementStepDisplayLines = 3+    fromEnum MovementStepDisplayLineEnds = 4+    fromEnum MovementStepParagraphs = 5+    fromEnum MovementStepParagraphEnds = 6+    fromEnum MovementStepPages = 7+    fromEnum MovementStepBufferEnds = 8+    fromEnum MovementStepHorizontalPages = 9+    fromEnum (AnotherMovementStep k) = k++    toEnum 0 = MovementStepLogicalPositions+    toEnum 1 = MovementStepVisualPositions+    toEnum 2 = MovementStepWords+    toEnum 3 = MovementStepDisplayLines+    toEnum 4 = MovementStepDisplayLineEnds+    toEnum 5 = MovementStepParagraphs+    toEnum 6 = MovementStepParagraphEnds+    toEnum 7 = MovementStepPages+    toEnum 8 = MovementStepBufferEnds+    toEnum 9 = MovementStepHorizontalPages+    toEnum k = AnotherMovementStep k++foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type :: +    IO GType++instance BoxedEnum MovementStep where+    boxedEnumType _ = c_gtk_movement_step_get_type++-- Enum MessageType++data MessageType = +      MessageTypeInfo+    | MessageTypeWarning+    | MessageTypeQuestion+    | MessageTypeError+    | MessageTypeOther+    | AnotherMessageType Int+    deriving (Show, Eq)++instance Enum MessageType where+    fromEnum MessageTypeInfo = 0+    fromEnum MessageTypeWarning = 1+    fromEnum MessageTypeQuestion = 2+    fromEnum MessageTypeError = 3+    fromEnum MessageTypeOther = 4+    fromEnum (AnotherMessageType k) = k++    toEnum 0 = MessageTypeInfo+    toEnum 1 = MessageTypeWarning+    toEnum 2 = MessageTypeQuestion+    toEnum 3 = MessageTypeError+    toEnum 4 = MessageTypeOther+    toEnum k = AnotherMessageType k++foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type :: +    IO GType++instance BoxedEnum MessageType where+    boxedEnumType _ = c_gtk_message_type_get_type++-- Enum MenuDirectionType++data MenuDirectionType = +      MenuDirectionTypeParent+    | MenuDirectionTypeChild+    | MenuDirectionTypeNext+    | MenuDirectionTypePrev+    | AnotherMenuDirectionType Int+    deriving (Show, Eq)++instance Enum MenuDirectionType where+    fromEnum MenuDirectionTypeParent = 0+    fromEnum MenuDirectionTypeChild = 1+    fromEnum MenuDirectionTypeNext = 2+    fromEnum MenuDirectionTypePrev = 3+    fromEnum (AnotherMenuDirectionType k) = k++    toEnum 0 = MenuDirectionTypeParent+    toEnum 1 = MenuDirectionTypeChild+    toEnum 2 = MenuDirectionTypeNext+    toEnum 3 = MenuDirectionTypePrev+    toEnum k = AnotherMenuDirectionType k++foreign import ccall "gtk_menu_direction_type_get_type" c_gtk_menu_direction_type_get_type :: +    IO GType++instance BoxedEnum MenuDirectionType where+    boxedEnumType _ = c_gtk_menu_direction_type_get_type++-- Enum License++data License = +      LicenseUnknown+    | LicenseCustom+    | LicenseGpl20+    | LicenseGpl30+    | LicenseLgpl21+    | LicenseLgpl30+    | LicenseBsd+    | LicenseMitX11+    | LicenseArtistic+    | LicenseGpl20Only+    | LicenseGpl30Only+    | LicenseLgpl21Only+    | LicenseLgpl30Only+    | AnotherLicense Int+    deriving (Show, Eq)++instance Enum License where+    fromEnum LicenseUnknown = 0+    fromEnum LicenseCustom = 1+    fromEnum LicenseGpl20 = 2+    fromEnum LicenseGpl30 = 3+    fromEnum LicenseLgpl21 = 4+    fromEnum LicenseLgpl30 = 5+    fromEnum LicenseBsd = 6+    fromEnum LicenseMitX11 = 7+    fromEnum LicenseArtistic = 8+    fromEnum LicenseGpl20Only = 9+    fromEnum LicenseGpl30Only = 10+    fromEnum LicenseLgpl21Only = 11+    fromEnum LicenseLgpl30Only = 12+    fromEnum (AnotherLicense k) = k++    toEnum 0 = LicenseUnknown+    toEnum 1 = LicenseCustom+    toEnum 2 = LicenseGpl20+    toEnum 3 = LicenseGpl30+    toEnum 4 = LicenseLgpl21+    toEnum 5 = LicenseLgpl30+    toEnum 6 = LicenseBsd+    toEnum 7 = LicenseMitX11+    toEnum 8 = LicenseArtistic+    toEnum 9 = LicenseGpl20Only+    toEnum 10 = LicenseGpl30Only+    toEnum 11 = LicenseLgpl21Only+    toEnum 12 = LicenseLgpl30Only+    toEnum k = AnotherLicense k++foreign import ccall "gtk_license_get_type" c_gtk_license_get_type :: +    IO GType++instance BoxedEnum License where+    boxedEnumType _ = c_gtk_license_get_type++-- Enum LevelBarMode++data LevelBarMode = +      LevelBarModeContinuous+    | LevelBarModeDiscrete+    | AnotherLevelBarMode Int+    deriving (Show, Eq)++instance Enum LevelBarMode where+    fromEnum LevelBarModeContinuous = 0+    fromEnum LevelBarModeDiscrete = 1+    fromEnum (AnotherLevelBarMode k) = k++    toEnum 0 = LevelBarModeContinuous+    toEnum 1 = LevelBarModeDiscrete+    toEnum k = AnotherLevelBarMode k++foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type :: +    IO GType++instance BoxedEnum LevelBarMode where+    boxedEnumType _ = c_gtk_level_bar_mode_get_type++-- Enum Justification++data Justification = +      JustificationLeft+    | JustificationRight+    | JustificationCenter+    | JustificationFill+    | AnotherJustification Int+    deriving (Show, Eq)++instance Enum Justification where+    fromEnum JustificationLeft = 0+    fromEnum JustificationRight = 1+    fromEnum JustificationCenter = 2+    fromEnum JustificationFill = 3+    fromEnum (AnotherJustification k) = k++    toEnum 0 = JustificationLeft+    toEnum 1 = JustificationRight+    toEnum 2 = JustificationCenter+    toEnum 3 = JustificationFill+    toEnum k = AnotherJustification k++foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type :: +    IO GType++instance BoxedEnum Justification where+    boxedEnumType _ = c_gtk_justification_get_type++-- Enum InputPurpose++data InputPurpose = +      InputPurposeFreeForm+    | InputPurposeAlpha+    | InputPurposeDigits+    | InputPurposeNumber+    | InputPurposePhone+    | InputPurposeUrl+    | InputPurposeEmail+    | InputPurposeName+    | InputPurposePassword+    | InputPurposePin+    | AnotherInputPurpose Int+    deriving (Show, Eq)++instance Enum InputPurpose where+    fromEnum InputPurposeFreeForm = 0+    fromEnum InputPurposeAlpha = 1+    fromEnum InputPurposeDigits = 2+    fromEnum InputPurposeNumber = 3+    fromEnum InputPurposePhone = 4+    fromEnum InputPurposeUrl = 5+    fromEnum InputPurposeEmail = 6+    fromEnum InputPurposeName = 7+    fromEnum InputPurposePassword = 8+    fromEnum InputPurposePin = 9+    fromEnum (AnotherInputPurpose k) = k++    toEnum 0 = InputPurposeFreeForm+    toEnum 1 = InputPurposeAlpha+    toEnum 2 = InputPurposeDigits+    toEnum 3 = InputPurposeNumber+    toEnum 4 = InputPurposePhone+    toEnum 5 = InputPurposeUrl+    toEnum 6 = InputPurposeEmail+    toEnum 7 = InputPurposeName+    toEnum 8 = InputPurposePassword+    toEnum 9 = InputPurposePin+    toEnum k = AnotherInputPurpose k++foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type :: +    IO GType++instance BoxedEnum InputPurpose where+    boxedEnumType _ = c_gtk_input_purpose_get_type++-- Enum ImageType++data ImageType = +      ImageTypeEmpty+    | ImageTypePixbuf+    | ImageTypeStock+    | ImageTypeIconSet+    | ImageTypeAnimation+    | ImageTypeIconName+    | ImageTypeGicon+    | ImageTypeSurface+    | AnotherImageType Int+    deriving (Show, Eq)++instance Enum ImageType where+    fromEnum ImageTypeEmpty = 0+    fromEnum ImageTypePixbuf = 1+    fromEnum ImageTypeStock = 2+    fromEnum ImageTypeIconSet = 3+    fromEnum ImageTypeAnimation = 4+    fromEnum ImageTypeIconName = 5+    fromEnum ImageTypeGicon = 6+    fromEnum ImageTypeSurface = 7+    fromEnum (AnotherImageType k) = k++    toEnum 0 = ImageTypeEmpty+    toEnum 1 = ImageTypePixbuf+    toEnum 2 = ImageTypeStock+    toEnum 3 = ImageTypeIconSet+    toEnum 4 = ImageTypeAnimation+    toEnum 5 = ImageTypeIconName+    toEnum 6 = ImageTypeGicon+    toEnum 7 = ImageTypeSurface+    toEnum k = AnotherImageType k++foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type :: +    IO GType++instance BoxedEnum ImageType where+    boxedEnumType _ = c_gtk_image_type_get_type++-- Enum IconViewDropPosition++data IconViewDropPosition = +      IconViewDropPositionNoDrop+    | IconViewDropPositionDropInto+    | IconViewDropPositionDropLeft+    | IconViewDropPositionDropRight+    | IconViewDropPositionDropAbove+    | IconViewDropPositionDropBelow+    | AnotherIconViewDropPosition Int+    deriving (Show, Eq)++instance Enum IconViewDropPosition where+    fromEnum IconViewDropPositionNoDrop = 0+    fromEnum IconViewDropPositionDropInto = 1+    fromEnum IconViewDropPositionDropLeft = 2+    fromEnum IconViewDropPositionDropRight = 3+    fromEnum IconViewDropPositionDropAbove = 4+    fromEnum IconViewDropPositionDropBelow = 5+    fromEnum (AnotherIconViewDropPosition k) = k++    toEnum 0 = IconViewDropPositionNoDrop+    toEnum 1 = IconViewDropPositionDropInto+    toEnum 2 = IconViewDropPositionDropLeft+    toEnum 3 = IconViewDropPositionDropRight+    toEnum 4 = IconViewDropPositionDropAbove+    toEnum 5 = IconViewDropPositionDropBelow+    toEnum k = AnotherIconViewDropPosition k++foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type :: +    IO GType++instance BoxedEnum IconViewDropPosition where+    boxedEnumType _ = c_gtk_icon_view_drop_position_get_type++-- Enum IconThemeError++data IconThemeError = +      IconThemeErrorNotFound+    | IconThemeErrorFailed+    | AnotherIconThemeError Int+    deriving (Show, Eq)++instance Enum IconThemeError where+    fromEnum IconThemeErrorNotFound = 0+    fromEnum IconThemeErrorFailed = 1+    fromEnum (AnotherIconThemeError k) = k++    toEnum 0 = IconThemeErrorNotFound+    toEnum 1 = IconThemeErrorFailed+    toEnum k = AnotherIconThemeError k++instance GErrorClass IconThemeError where+    gerrorClassDomain _ = "gtk-icon-theme-error-quark"++catchIconThemeError ::+    IO a ->+    (IconThemeError -> GErrorMessage -> IO a) ->+    IO a+catchIconThemeError = catchGErrorJustDomain++handleIconThemeError ::+    (IconThemeError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleIconThemeError = handleGErrorJustDomain++foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type :: +    IO GType++instance BoxedEnum IconThemeError where+    boxedEnumType _ = c_gtk_icon_theme_error_get_type++-- Enum IconSize++data IconSize = +      IconSizeInvalid+    | IconSizeMenu+    | IconSizeSmallToolbar+    | IconSizeLargeToolbar+    | IconSizeButton+    | IconSizeDnd+    | IconSizeDialog+    | AnotherIconSize Int+    deriving (Show, Eq)++instance Enum IconSize where+    fromEnum IconSizeInvalid = 0+    fromEnum IconSizeMenu = 1+    fromEnum IconSizeSmallToolbar = 2+    fromEnum IconSizeLargeToolbar = 3+    fromEnum IconSizeButton = 4+    fromEnum IconSizeDnd = 5+    fromEnum IconSizeDialog = 6+    fromEnum (AnotherIconSize k) = k++    toEnum 0 = IconSizeInvalid+    toEnum 1 = IconSizeMenu+    toEnum 2 = IconSizeSmallToolbar+    toEnum 3 = IconSizeLargeToolbar+    toEnum 4 = IconSizeButton+    toEnum 5 = IconSizeDnd+    toEnum 6 = IconSizeDialog+    toEnum k = AnotherIconSize k++foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type :: +    IO GType++instance BoxedEnum IconSize where+    boxedEnumType _ = c_gtk_icon_size_get_type++-- Enum IMStatusStyle+{-# DEPRECATED IMStatusStyle ["(Since version 3.10)"]#-}+data IMStatusStyle = +      IMStatusStyleNothing+    | IMStatusStyleCallback+    | IMStatusStyleNone+    | AnotherIMStatusStyle Int+    deriving (Show, Eq)++instance Enum IMStatusStyle where+    fromEnum IMStatusStyleNothing = 0+    fromEnum IMStatusStyleCallback = 1+    fromEnum IMStatusStyleNone = 2+    fromEnum (AnotherIMStatusStyle k) = k++    toEnum 0 = IMStatusStyleNothing+    toEnum 1 = IMStatusStyleCallback+    toEnum 2 = IMStatusStyleNone+    toEnum k = AnotherIMStatusStyle k++foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type :: +    IO GType++instance BoxedEnum IMStatusStyle where+    boxedEnumType _ = c_gtk_im_status_style_get_type++-- Enum IMPreeditStyle+{-# DEPRECATED IMPreeditStyle ["(Since version 3.10)"]#-}+data IMPreeditStyle = +      IMPreeditStyleNothing+    | IMPreeditStyleCallback+    | IMPreeditStyleNone+    | AnotherIMPreeditStyle Int+    deriving (Show, Eq)++instance Enum IMPreeditStyle where+    fromEnum IMPreeditStyleNothing = 0+    fromEnum IMPreeditStyleCallback = 1+    fromEnum IMPreeditStyleNone = 2+    fromEnum (AnotherIMPreeditStyle k) = k++    toEnum 0 = IMPreeditStyleNothing+    toEnum 1 = IMPreeditStyleCallback+    toEnum 2 = IMPreeditStyleNone+    toEnum k = AnotherIMPreeditStyle k++foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type :: +    IO GType++instance BoxedEnum IMPreeditStyle where+    boxedEnumType _ = c_gtk_im_preedit_style_get_type++-- Enum FileChooserError++data FileChooserError = +      FileChooserErrorNonexistent+    | FileChooserErrorBadFilename+    | FileChooserErrorAlreadyExists+    | FileChooserErrorIncompleteHostname+    | AnotherFileChooserError Int+    deriving (Show, Eq)++instance Enum FileChooserError where+    fromEnum FileChooserErrorNonexistent = 0+    fromEnum FileChooserErrorBadFilename = 1+    fromEnum FileChooserErrorAlreadyExists = 2+    fromEnum FileChooserErrorIncompleteHostname = 3+    fromEnum (AnotherFileChooserError k) = k++    toEnum 0 = FileChooserErrorNonexistent+    toEnum 1 = FileChooserErrorBadFilename+    toEnum 2 = FileChooserErrorAlreadyExists+    toEnum 3 = FileChooserErrorIncompleteHostname+    toEnum k = AnotherFileChooserError k++instance GErrorClass FileChooserError where+    gerrorClassDomain _ = "gtk-file-chooser-error-quark"++catchFileChooserError ::+    IO a ->+    (FileChooserError -> GErrorMessage -> IO a) ->+    IO a+catchFileChooserError = catchGErrorJustDomain++handleFileChooserError ::+    (FileChooserError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleFileChooserError = handleGErrorJustDomain++foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type :: +    IO GType++instance BoxedEnum FileChooserError where+    boxedEnumType _ = c_gtk_file_chooser_error_get_type++-- Enum FileChooserConfirmation++data FileChooserConfirmation = +      FileChooserConfirmationConfirm+    | FileChooserConfirmationAcceptFilename+    | FileChooserConfirmationSelectAgain+    | AnotherFileChooserConfirmation Int+    deriving (Show, Eq)++instance Enum FileChooserConfirmation where+    fromEnum FileChooserConfirmationConfirm = 0+    fromEnum FileChooserConfirmationAcceptFilename = 1+    fromEnum FileChooserConfirmationSelectAgain = 2+    fromEnum (AnotherFileChooserConfirmation k) = k++    toEnum 0 = FileChooserConfirmationConfirm+    toEnum 1 = FileChooserConfirmationAcceptFilename+    toEnum 2 = FileChooserConfirmationSelectAgain+    toEnum k = AnotherFileChooserConfirmation k++foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type :: +    IO GType++instance BoxedEnum FileChooserConfirmation where+    boxedEnumType _ = c_gtk_file_chooser_confirmation_get_type++-- Enum FileChooserAction++data FileChooserAction = +      FileChooserActionOpen+    | FileChooserActionSave+    | FileChooserActionSelectFolder+    | FileChooserActionCreateFolder+    | AnotherFileChooserAction Int+    deriving (Show, Eq)++instance Enum FileChooserAction where+    fromEnum FileChooserActionOpen = 0+    fromEnum FileChooserActionSave = 1+    fromEnum FileChooserActionSelectFolder = 2+    fromEnum FileChooserActionCreateFolder = 3+    fromEnum (AnotherFileChooserAction k) = k++    toEnum 0 = FileChooserActionOpen+    toEnum 1 = FileChooserActionSave+    toEnum 2 = FileChooserActionSelectFolder+    toEnum 3 = FileChooserActionCreateFolder+    toEnum k = AnotherFileChooserAction k++foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type :: +    IO GType++instance BoxedEnum FileChooserAction where+    boxedEnumType _ = c_gtk_file_chooser_action_get_type++-- Enum ExpanderStyle++data ExpanderStyle = +      ExpanderStyleCollapsed+    | ExpanderStyleSemiCollapsed+    | ExpanderStyleSemiExpanded+    | ExpanderStyleExpanded+    | AnotherExpanderStyle Int+    deriving (Show, Eq)++instance Enum ExpanderStyle where+    fromEnum ExpanderStyleCollapsed = 0+    fromEnum ExpanderStyleSemiCollapsed = 1+    fromEnum ExpanderStyleSemiExpanded = 2+    fromEnum ExpanderStyleExpanded = 3+    fromEnum (AnotherExpanderStyle k) = k++    toEnum 0 = ExpanderStyleCollapsed+    toEnum 1 = ExpanderStyleSemiCollapsed+    toEnum 2 = ExpanderStyleSemiExpanded+    toEnum 3 = ExpanderStyleExpanded+    toEnum k = AnotherExpanderStyle k++foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type :: +    IO GType++instance BoxedEnum ExpanderStyle where+    boxedEnumType _ = c_gtk_expander_style_get_type++-- Enum EventSequenceState++data EventSequenceState = +      EventSequenceStateNone+    | EventSequenceStateClaimed+    | EventSequenceStateDenied+    | AnotherEventSequenceState Int+    deriving (Show, Eq)++instance Enum EventSequenceState where+    fromEnum EventSequenceStateNone = 0+    fromEnum EventSequenceStateClaimed = 1+    fromEnum EventSequenceStateDenied = 2+    fromEnum (AnotherEventSequenceState k) = k++    toEnum 0 = EventSequenceStateNone+    toEnum 1 = EventSequenceStateClaimed+    toEnum 2 = EventSequenceStateDenied+    toEnum k = AnotherEventSequenceState k++foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type :: +    IO GType++instance BoxedEnum EventSequenceState where+    boxedEnumType _ = c_gtk_event_sequence_state_get_type++-- Enum EntryIconPosition++data EntryIconPosition = +      EntryIconPositionPrimary+    | EntryIconPositionSecondary+    | AnotherEntryIconPosition Int+    deriving (Show, Eq)++instance Enum EntryIconPosition where+    fromEnum EntryIconPositionPrimary = 0+    fromEnum EntryIconPositionSecondary = 1+    fromEnum (AnotherEntryIconPosition k) = k++    toEnum 0 = EntryIconPositionPrimary+    toEnum 1 = EntryIconPositionSecondary+    toEnum k = AnotherEntryIconPosition k++foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type :: +    IO GType++instance BoxedEnum EntryIconPosition where+    boxedEnumType _ = c_gtk_entry_icon_position_get_type++-- Enum DragResult++data DragResult = +      DragResultSuccess+    | DragResultNoTarget+    | DragResultUserCancelled+    | DragResultTimeoutExpired+    | DragResultGrabBroken+    | DragResultError+    | AnotherDragResult Int+    deriving (Show, Eq)++instance Enum DragResult where+    fromEnum DragResultSuccess = 0+    fromEnum DragResultNoTarget = 1+    fromEnum DragResultUserCancelled = 2+    fromEnum DragResultTimeoutExpired = 3+    fromEnum DragResultGrabBroken = 4+    fromEnum DragResultError = 5+    fromEnum (AnotherDragResult k) = k++    toEnum 0 = DragResultSuccess+    toEnum 1 = DragResultNoTarget+    toEnum 2 = DragResultUserCancelled+    toEnum 3 = DragResultTimeoutExpired+    toEnum 4 = DragResultGrabBroken+    toEnum 5 = DragResultError+    toEnum k = AnotherDragResult k++foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type :: +    IO GType++instance BoxedEnum DragResult where+    boxedEnumType _ = c_gtk_drag_result_get_type++-- Enum DirectionType++data DirectionType = +      DirectionTypeTabForward+    | DirectionTypeTabBackward+    | DirectionTypeUp+    | DirectionTypeDown+    | DirectionTypeLeft+    | DirectionTypeRight+    | AnotherDirectionType Int+    deriving (Show, Eq)++instance Enum DirectionType where+    fromEnum DirectionTypeTabForward = 0+    fromEnum DirectionTypeTabBackward = 1+    fromEnum DirectionTypeUp = 2+    fromEnum DirectionTypeDown = 3+    fromEnum DirectionTypeLeft = 4+    fromEnum DirectionTypeRight = 5+    fromEnum (AnotherDirectionType k) = k++    toEnum 0 = DirectionTypeTabForward+    toEnum 1 = DirectionTypeTabBackward+    toEnum 2 = DirectionTypeUp+    toEnum 3 = DirectionTypeDown+    toEnum 4 = DirectionTypeLeft+    toEnum 5 = DirectionTypeRight+    toEnum k = AnotherDirectionType k++foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type :: +    IO GType++instance BoxedEnum DirectionType where+    boxedEnumType _ = c_gtk_direction_type_get_type++-- Enum DeleteType++data DeleteType = +      DeleteTypeChars+    | DeleteTypeWordEnds+    | DeleteTypeWords+    | DeleteTypeDisplayLines+    | DeleteTypeDisplayLineEnds+    | DeleteTypeParagraphEnds+    | DeleteTypeParagraphs+    | DeleteTypeWhitespace+    | AnotherDeleteType Int+    deriving (Show, Eq)++instance Enum DeleteType where+    fromEnum DeleteTypeChars = 0+    fromEnum DeleteTypeWordEnds = 1+    fromEnum DeleteTypeWords = 2+    fromEnum DeleteTypeDisplayLines = 3+    fromEnum DeleteTypeDisplayLineEnds = 4+    fromEnum DeleteTypeParagraphEnds = 5+    fromEnum DeleteTypeParagraphs = 6+    fromEnum DeleteTypeWhitespace = 7+    fromEnum (AnotherDeleteType k) = k++    toEnum 0 = DeleteTypeChars+    toEnum 1 = DeleteTypeWordEnds+    toEnum 2 = DeleteTypeWords+    toEnum 3 = DeleteTypeDisplayLines+    toEnum 4 = DeleteTypeDisplayLineEnds+    toEnum 5 = DeleteTypeParagraphEnds+    toEnum 6 = DeleteTypeParagraphs+    toEnum 7 = DeleteTypeWhitespace+    toEnum k = AnotherDeleteType k++foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type :: +    IO GType++instance BoxedEnum DeleteType where+    boxedEnumType _ = c_gtk_delete_type_get_type++-- Enum CssSectionType++data CssSectionType = +      CssSectionTypeDocument+    | CssSectionTypeImport+    | CssSectionTypeColorDefinition+    | CssSectionTypeBindingSet+    | CssSectionTypeRuleset+    | CssSectionTypeSelector+    | CssSectionTypeDeclaration+    | CssSectionTypeValue+    | CssSectionTypeKeyframes+    | AnotherCssSectionType Int+    deriving (Show, Eq)++instance Enum CssSectionType where+    fromEnum CssSectionTypeDocument = 0+    fromEnum CssSectionTypeImport = 1+    fromEnum CssSectionTypeColorDefinition = 2+    fromEnum CssSectionTypeBindingSet = 3+    fromEnum CssSectionTypeRuleset = 4+    fromEnum CssSectionTypeSelector = 5+    fromEnum CssSectionTypeDeclaration = 6+    fromEnum CssSectionTypeValue = 7+    fromEnum CssSectionTypeKeyframes = 8+    fromEnum (AnotherCssSectionType k) = k++    toEnum 0 = CssSectionTypeDocument+    toEnum 1 = CssSectionTypeImport+    toEnum 2 = CssSectionTypeColorDefinition+    toEnum 3 = CssSectionTypeBindingSet+    toEnum 4 = CssSectionTypeRuleset+    toEnum 5 = CssSectionTypeSelector+    toEnum 6 = CssSectionTypeDeclaration+    toEnum 7 = CssSectionTypeValue+    toEnum 8 = CssSectionTypeKeyframes+    toEnum k = AnotherCssSectionType k++foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type :: +    IO GType++instance BoxedEnum CssSectionType where+    boxedEnumType _ = c_gtk_css_section_type_get_type++-- Enum CssProviderError++data CssProviderError = +      CssProviderErrorFailed+    | CssProviderErrorSyntax+    | CssProviderErrorImport+    | CssProviderErrorName+    | CssProviderErrorDeprecated+    | CssProviderErrorUnknownValue+    | AnotherCssProviderError Int+    deriving (Show, Eq)++instance Enum CssProviderError where+    fromEnum CssProviderErrorFailed = 0+    fromEnum CssProviderErrorSyntax = 1+    fromEnum CssProviderErrorImport = 2+    fromEnum CssProviderErrorName = 3+    fromEnum CssProviderErrorDeprecated = 4+    fromEnum CssProviderErrorUnknownValue = 5+    fromEnum (AnotherCssProviderError k) = k++    toEnum 0 = CssProviderErrorFailed+    toEnum 1 = CssProviderErrorSyntax+    toEnum 2 = CssProviderErrorImport+    toEnum 3 = CssProviderErrorName+    toEnum 4 = CssProviderErrorDeprecated+    toEnum 5 = CssProviderErrorUnknownValue+    toEnum k = AnotherCssProviderError k++instance GErrorClass CssProviderError where+    gerrorClassDomain _ = "gtk-css-provider-error-quark"++catchCssProviderError ::+    IO a ->+    (CssProviderError -> GErrorMessage -> IO a) ->+    IO a+catchCssProviderError = catchGErrorJustDomain++handleCssProviderError ::+    (CssProviderError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleCssProviderError = handleGErrorJustDomain++foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type :: +    IO GType++instance BoxedEnum CssProviderError where+    boxedEnumType _ = c_gtk_css_provider_error_get_type++-- Enum CornerType++data CornerType = +      CornerTypeTopLeft+    | CornerTypeBottomLeft+    | CornerTypeTopRight+    | CornerTypeBottomRight+    | AnotherCornerType Int+    deriving (Show, Eq)++instance Enum CornerType where+    fromEnum CornerTypeTopLeft = 0+    fromEnum CornerTypeBottomLeft = 1+    fromEnum CornerTypeTopRight = 2+    fromEnum CornerTypeBottomRight = 3+    fromEnum (AnotherCornerType k) = k++    toEnum 0 = CornerTypeTopLeft+    toEnum 1 = CornerTypeBottomLeft+    toEnum 2 = CornerTypeTopRight+    toEnum 3 = CornerTypeBottomRight+    toEnum k = AnotherCornerType k++foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type :: +    IO GType++instance BoxedEnum CornerType where+    boxedEnumType _ = c_gtk_corner_type_get_type++-- Enum CellRendererMode++data CellRendererMode = +      CellRendererModeInert+    | CellRendererModeActivatable+    | CellRendererModeEditable+    | AnotherCellRendererMode Int+    deriving (Show, Eq)++instance Enum CellRendererMode where+    fromEnum CellRendererModeInert = 0+    fromEnum CellRendererModeActivatable = 1+    fromEnum CellRendererModeEditable = 2+    fromEnum (AnotherCellRendererMode k) = k++    toEnum 0 = CellRendererModeInert+    toEnum 1 = CellRendererModeActivatable+    toEnum 2 = CellRendererModeEditable+    toEnum k = AnotherCellRendererMode k++foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type :: +    IO GType++instance BoxedEnum CellRendererMode where+    boxedEnumType _ = c_gtk_cell_renderer_mode_get_type++-- Enum CellRendererAccelMode++data CellRendererAccelMode = +      CellRendererAccelModeGtk+    | CellRendererAccelModeOther+    | AnotherCellRendererAccelMode Int+    deriving (Show, Eq)++instance Enum CellRendererAccelMode where+    fromEnum CellRendererAccelModeGtk = 0+    fromEnum CellRendererAccelModeOther = 1+    fromEnum (AnotherCellRendererAccelMode k) = k++    toEnum 0 = CellRendererAccelModeGtk+    toEnum 1 = CellRendererAccelModeOther+    toEnum k = AnotherCellRendererAccelMode k++foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type :: +    IO GType++instance BoxedEnum CellRendererAccelMode where+    boxedEnumType _ = c_gtk_cell_renderer_accel_mode_get_type++-- Enum ButtonsType++data ButtonsType = +      ButtonsTypeNone+    | ButtonsTypeOk+    | ButtonsTypeClose+    | ButtonsTypeCancel+    | ButtonsTypeYesNo+    | ButtonsTypeOkCancel+    | AnotherButtonsType Int+    deriving (Show, Eq)++instance Enum ButtonsType where+    fromEnum ButtonsTypeNone = 0+    fromEnum ButtonsTypeOk = 1+    fromEnum ButtonsTypeClose = 2+    fromEnum ButtonsTypeCancel = 3+    fromEnum ButtonsTypeYesNo = 4+    fromEnum ButtonsTypeOkCancel = 5+    fromEnum (AnotherButtonsType k) = k++    toEnum 0 = ButtonsTypeNone+    toEnum 1 = ButtonsTypeOk+    toEnum 2 = ButtonsTypeClose+    toEnum 3 = ButtonsTypeCancel+    toEnum 4 = ButtonsTypeYesNo+    toEnum 5 = ButtonsTypeOkCancel+    toEnum k = AnotherButtonsType k++foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type :: +    IO GType++instance BoxedEnum ButtonsType where+    boxedEnumType _ = c_gtk_buttons_type_get_type++-- Enum ButtonRole++data ButtonRole = +      ButtonRoleNormal+    | ButtonRoleCheck+    | ButtonRoleRadio+    | AnotherButtonRole Int+    deriving (Show, Eq)++instance Enum ButtonRole where+    fromEnum ButtonRoleNormal = 0+    fromEnum ButtonRoleCheck = 1+    fromEnum ButtonRoleRadio = 2+    fromEnum (AnotherButtonRole k) = k++    toEnum 0 = ButtonRoleNormal+    toEnum 1 = ButtonRoleCheck+    toEnum 2 = ButtonRoleRadio+    toEnum k = AnotherButtonRole k++foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type :: +    IO GType++instance BoxedEnum ButtonRole where+    boxedEnumType _ = c_gtk_button_role_get_type++-- Enum ButtonBoxStyle++data ButtonBoxStyle = +      ButtonBoxStyleSpread+    | ButtonBoxStyleEdge+    | ButtonBoxStyleStart+    | ButtonBoxStyleEnd+    | ButtonBoxStyleCenter+    | ButtonBoxStyleExpand+    | AnotherButtonBoxStyle Int+    deriving (Show, Eq)++instance Enum ButtonBoxStyle where+    fromEnum ButtonBoxStyleSpread = 1+    fromEnum ButtonBoxStyleEdge = 2+    fromEnum ButtonBoxStyleStart = 3+    fromEnum ButtonBoxStyleEnd = 4+    fromEnum ButtonBoxStyleCenter = 5+    fromEnum ButtonBoxStyleExpand = 6+    fromEnum (AnotherButtonBoxStyle k) = k++    toEnum 1 = ButtonBoxStyleSpread+    toEnum 2 = ButtonBoxStyleEdge+    toEnum 3 = ButtonBoxStyleStart+    toEnum 4 = ButtonBoxStyleEnd+    toEnum 5 = ButtonBoxStyleCenter+    toEnum 6 = ButtonBoxStyleExpand+    toEnum k = AnotherButtonBoxStyle k++foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type :: +    IO GType++instance BoxedEnum ButtonBoxStyle where+    boxedEnumType _ = c_gtk_button_box_style_get_type++-- Enum BuilderError++data BuilderError = +      BuilderErrorInvalidTypeFunction+    | BuilderErrorUnhandledTag+    | BuilderErrorMissingAttribute+    | BuilderErrorInvalidAttribute+    | BuilderErrorInvalidTag+    | BuilderErrorMissingPropertyValue+    | BuilderErrorInvalidValue+    | BuilderErrorVersionMismatch+    | BuilderErrorDuplicateId+    | BuilderErrorObjectTypeRefused+    | BuilderErrorTemplateMismatch+    | BuilderErrorInvalidProperty+    | BuilderErrorInvalidSignal+    | BuilderErrorInvalidId+    | AnotherBuilderError Int+    deriving (Show, Eq)++instance Enum BuilderError where+    fromEnum BuilderErrorInvalidTypeFunction = 0+    fromEnum BuilderErrorUnhandledTag = 1+    fromEnum BuilderErrorMissingAttribute = 2+    fromEnum BuilderErrorInvalidAttribute = 3+    fromEnum BuilderErrorInvalidTag = 4+    fromEnum BuilderErrorMissingPropertyValue = 5+    fromEnum BuilderErrorInvalidValue = 6+    fromEnum BuilderErrorVersionMismatch = 7+    fromEnum BuilderErrorDuplicateId = 8+    fromEnum BuilderErrorObjectTypeRefused = 9+    fromEnum BuilderErrorTemplateMismatch = 10+    fromEnum BuilderErrorInvalidProperty = 11+    fromEnum BuilderErrorInvalidSignal = 12+    fromEnum BuilderErrorInvalidId = 13+    fromEnum (AnotherBuilderError k) = k++    toEnum 0 = BuilderErrorInvalidTypeFunction+    toEnum 1 = BuilderErrorUnhandledTag+    toEnum 2 = BuilderErrorMissingAttribute+    toEnum 3 = BuilderErrorInvalidAttribute+    toEnum 4 = BuilderErrorInvalidTag+    toEnum 5 = BuilderErrorMissingPropertyValue+    toEnum 6 = BuilderErrorInvalidValue+    toEnum 7 = BuilderErrorVersionMismatch+    toEnum 8 = BuilderErrorDuplicateId+    toEnum 9 = BuilderErrorObjectTypeRefused+    toEnum 10 = BuilderErrorTemplateMismatch+    toEnum 11 = BuilderErrorInvalidProperty+    toEnum 12 = BuilderErrorInvalidSignal+    toEnum 13 = BuilderErrorInvalidId+    toEnum k = AnotherBuilderError k++instance GErrorClass BuilderError where+    gerrorClassDomain _ = "gtk-builder-error-quark"++catchBuilderError ::+    IO a ->+    (BuilderError -> GErrorMessage -> IO a) ->+    IO a+catchBuilderError = catchGErrorJustDomain++handleBuilderError ::+    (BuilderError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleBuilderError = handleGErrorJustDomain++foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type :: +    IO GType++instance BoxedEnum BuilderError where+    boxedEnumType _ = c_gtk_builder_error_get_type++-- Enum BorderStyle++data BorderStyle = +      BorderStyleNone+    | BorderStyleSolid+    | BorderStyleInset+    | BorderStyleOutset+    | BorderStyleHidden+    | BorderStyleDotted+    | BorderStyleDashed+    | BorderStyleDouble+    | BorderStyleGroove+    | BorderStyleRidge+    | AnotherBorderStyle Int+    deriving (Show, Eq)++instance Enum BorderStyle where+    fromEnum BorderStyleNone = 0+    fromEnum BorderStyleSolid = 1+    fromEnum BorderStyleInset = 2+    fromEnum BorderStyleOutset = 3+    fromEnum BorderStyleHidden = 4+    fromEnum BorderStyleDotted = 5+    fromEnum BorderStyleDashed = 6+    fromEnum BorderStyleDouble = 7+    fromEnum BorderStyleGroove = 8+    fromEnum BorderStyleRidge = 9+    fromEnum (AnotherBorderStyle k) = k++    toEnum 0 = BorderStyleNone+    toEnum 1 = BorderStyleSolid+    toEnum 2 = BorderStyleInset+    toEnum 3 = BorderStyleOutset+    toEnum 4 = BorderStyleHidden+    toEnum 5 = BorderStyleDotted+    toEnum 6 = BorderStyleDashed+    toEnum 7 = BorderStyleDouble+    toEnum 8 = BorderStyleGroove+    toEnum 9 = BorderStyleRidge+    toEnum k = AnotherBorderStyle k++foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type :: +    IO GType++instance BoxedEnum BorderStyle where+    boxedEnumType _ = c_gtk_border_style_get_type++-- Enum BaselinePosition++data BaselinePosition = +      BaselinePositionTop+    | BaselinePositionCenter+    | BaselinePositionBottom+    | AnotherBaselinePosition Int+    deriving (Show, Eq)++instance Enum BaselinePosition where+    fromEnum BaselinePositionTop = 0+    fromEnum BaselinePositionCenter = 1+    fromEnum BaselinePositionBottom = 2+    fromEnum (AnotherBaselinePosition k) = k++    toEnum 0 = BaselinePositionTop+    toEnum 1 = BaselinePositionCenter+    toEnum 2 = BaselinePositionBottom+    toEnum k = AnotherBaselinePosition k++foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type :: +    IO GType++instance BoxedEnum BaselinePosition where+    boxedEnumType _ = c_gtk_baseline_position_get_type++-- Enum AssistantPageType++data AssistantPageType = +      AssistantPageTypeContent+    | AssistantPageTypeIntro+    | AssistantPageTypeConfirm+    | AssistantPageTypeSummary+    | AssistantPageTypeProgress+    | AssistantPageTypeCustom+    | AnotherAssistantPageType Int+    deriving (Show, Eq)++instance Enum AssistantPageType where+    fromEnum AssistantPageTypeContent = 0+    fromEnum AssistantPageTypeIntro = 1+    fromEnum AssistantPageTypeConfirm = 2+    fromEnum AssistantPageTypeSummary = 3+    fromEnum AssistantPageTypeProgress = 4+    fromEnum AssistantPageTypeCustom = 5+    fromEnum (AnotherAssistantPageType k) = k++    toEnum 0 = AssistantPageTypeContent+    toEnum 1 = AssistantPageTypeIntro+    toEnum 2 = AssistantPageTypeConfirm+    toEnum 3 = AssistantPageTypeSummary+    toEnum 4 = AssistantPageTypeProgress+    toEnum 5 = AssistantPageTypeCustom+    toEnum k = AnotherAssistantPageType k++foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type :: +    IO GType++instance BoxedEnum AssistantPageType where+    boxedEnumType _ = c_gtk_assistant_page_type_get_type++-- Enum ArrowType++data ArrowType = +      ArrowTypeUp+    | ArrowTypeDown+    | ArrowTypeLeft+    | ArrowTypeRight+    | ArrowTypeNone+    | AnotherArrowType Int+    deriving (Show, Eq)++instance Enum ArrowType where+    fromEnum ArrowTypeUp = 0+    fromEnum ArrowTypeDown = 1+    fromEnum ArrowTypeLeft = 2+    fromEnum ArrowTypeRight = 3+    fromEnum ArrowTypeNone = 4+    fromEnum (AnotherArrowType k) = k++    toEnum 0 = ArrowTypeUp+    toEnum 1 = ArrowTypeDown+    toEnum 2 = ArrowTypeLeft+    toEnum 3 = ArrowTypeRight+    toEnum 4 = ArrowTypeNone+    toEnum k = AnotherArrowType k++foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type :: +    IO GType++instance BoxedEnum ArrowType where+    boxedEnumType _ = c_gtk_arrow_type_get_type++-- Enum ArrowPlacement++data ArrowPlacement = +      ArrowPlacementBoth+    | ArrowPlacementStart+    | ArrowPlacementEnd+    | AnotherArrowPlacement Int+    deriving (Show, Eq)++instance Enum ArrowPlacement where+    fromEnum ArrowPlacementBoth = 0+    fromEnum ArrowPlacementStart = 1+    fromEnum ArrowPlacementEnd = 2+    fromEnum (AnotherArrowPlacement k) = k++    toEnum 0 = ArrowPlacementBoth+    toEnum 1 = ArrowPlacementStart+    toEnum 2 = ArrowPlacementEnd+    toEnum k = AnotherArrowPlacement k++foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type :: +    IO GType++instance BoxedEnum ArrowPlacement where+    boxedEnumType _ = c_gtk_arrow_placement_get_type++-- Enum Align++data Align = +      AlignFill+    | AlignStart+    | AlignEnd+    | AlignCenter+    | AlignBaseline+    | AnotherAlign Int+    deriving (Show, Eq)++instance Enum Align where+    fromEnum AlignFill = 0+    fromEnum AlignStart = 1+    fromEnum AlignEnd = 2+    fromEnum AlignCenter = 3+    fromEnum AlignBaseline = 4+    fromEnum (AnotherAlign k) = k++    toEnum 0 = AlignFill+    toEnum 1 = AlignStart+    toEnum 2 = AlignEnd+    toEnum 3 = AlignCenter+    toEnum 4 = AlignBaseline+    toEnum k = AnotherAlign k++foreign import ccall "gtk_align_get_type" c_gtk_align_get_type :: +    IO GType++instance BoxedEnum Align where+    boxedEnumType _ = c_gtk_align_get_type++
+ GI/Gtk/Flags.hs view
@@ -0,0 +1,871 @@++{- |+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.Gtk.Flags+    ( ++-- * Exported types+    UIManagerItemType(..)                   ,+    TreeModelFlags(..)                      ,+    ToolPaletteDragTargets(..)              ,+    TextSearchFlags(..)                     ,+    TargetFlags(..)                         ,+    StateFlags(..)                          ,+    RegionFlags(..)                         ,+    RecentFilterFlags(..)                   ,+    RcFlags(..)                             ,+    PlacesOpenFlags(..)                     ,+    JunctionSides(..)                       ,+    InputHints(..)                          ,+    IconLookupFlags(..)                     ,+    FileFilterFlags(..)                     ,+    DialogFlags(..)                         ,+    DestDefaults(..)                        ,+    DebugFlag(..)                           ,+    CellRendererState(..)                   ,+    CalendarDisplayOptions(..)              ,+    AttachOptions(..)                       ,+    ApplicationInhibitFlags(..)             ,+    AccelFlags(..)                          ,+++    ) where++import Prelude ()+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 UIManagerItemType+{-# DEPRECATED UIManagerItemType ["(Since version 3.10)"]#-}+data UIManagerItemType = +      UIManagerItemTypeAuto+    | UIManagerItemTypeMenubar+    | UIManagerItemTypeMenu+    | UIManagerItemTypeToolbar+    | UIManagerItemTypePlaceholder+    | UIManagerItemTypePopup+    | UIManagerItemTypeMenuitem+    | UIManagerItemTypeToolitem+    | UIManagerItemTypeSeparator+    | UIManagerItemTypeAccelerator+    | UIManagerItemTypePopupWithAccels+    | AnotherUIManagerItemType Int+    deriving (Show, Eq)++instance Enum UIManagerItemType where+    fromEnum UIManagerItemTypeAuto = 0+    fromEnum UIManagerItemTypeMenubar = 1+    fromEnum UIManagerItemTypeMenu = 2+    fromEnum UIManagerItemTypeToolbar = 4+    fromEnum UIManagerItemTypePlaceholder = 8+    fromEnum UIManagerItemTypePopup = 16+    fromEnum UIManagerItemTypeMenuitem = 32+    fromEnum UIManagerItemTypeToolitem = 64+    fromEnum UIManagerItemTypeSeparator = 128+    fromEnum UIManagerItemTypeAccelerator = 256+    fromEnum UIManagerItemTypePopupWithAccels = 512+    fromEnum (AnotherUIManagerItemType k) = k++    toEnum 0 = UIManagerItemTypeAuto+    toEnum 1 = UIManagerItemTypeMenubar+    toEnum 2 = UIManagerItemTypeMenu+    toEnum 4 = UIManagerItemTypeToolbar+    toEnum 8 = UIManagerItemTypePlaceholder+    toEnum 16 = UIManagerItemTypePopup+    toEnum 32 = UIManagerItemTypeMenuitem+    toEnum 64 = UIManagerItemTypeToolitem+    toEnum 128 = UIManagerItemTypeSeparator+    toEnum 256 = UIManagerItemTypeAccelerator+    toEnum 512 = UIManagerItemTypePopupWithAccels+    toEnum k = AnotherUIManagerItemType k++foreign import ccall "gtk_ui_manager_item_type_get_type" c_gtk_ui_manager_item_type_get_type :: +    IO GType++instance BoxedEnum UIManagerItemType where+    boxedEnumType _ = c_gtk_ui_manager_item_type_get_type++instance IsGFlag UIManagerItemType++-- Flags TreeModelFlags++data TreeModelFlags = +      TreeModelFlagsItersPersist+    | TreeModelFlagsListOnly+    | AnotherTreeModelFlags Int+    deriving (Show, Eq)++instance Enum TreeModelFlags where+    fromEnum TreeModelFlagsItersPersist = 1+    fromEnum TreeModelFlagsListOnly = 2+    fromEnum (AnotherTreeModelFlags k) = k++    toEnum 1 = TreeModelFlagsItersPersist+    toEnum 2 = TreeModelFlagsListOnly+    toEnum k = AnotherTreeModelFlags k++foreign import ccall "gtk_tree_model_flags_get_type" c_gtk_tree_model_flags_get_type :: +    IO GType++instance BoxedEnum TreeModelFlags where+    boxedEnumType _ = c_gtk_tree_model_flags_get_type++instance IsGFlag TreeModelFlags++-- Flags ToolPaletteDragTargets++data ToolPaletteDragTargets = +      ToolPaletteDragTargetsItems+    | ToolPaletteDragTargetsGroups+    | AnotherToolPaletteDragTargets Int+    deriving (Show, Eq)++instance Enum ToolPaletteDragTargets where+    fromEnum ToolPaletteDragTargetsItems = 1+    fromEnum ToolPaletteDragTargetsGroups = 2+    fromEnum (AnotherToolPaletteDragTargets k) = k++    toEnum 1 = ToolPaletteDragTargetsItems+    toEnum 2 = ToolPaletteDragTargetsGroups+    toEnum k = AnotherToolPaletteDragTargets k++foreign import ccall "gtk_tool_palette_drag_targets_get_type" c_gtk_tool_palette_drag_targets_get_type :: +    IO GType++instance BoxedEnum ToolPaletteDragTargets where+    boxedEnumType _ = c_gtk_tool_palette_drag_targets_get_type++instance IsGFlag ToolPaletteDragTargets++-- Flags TextSearchFlags++data TextSearchFlags = +      TextSearchFlagsVisibleOnly+    | TextSearchFlagsTextOnly+    | TextSearchFlagsCaseInsensitive+    | AnotherTextSearchFlags Int+    deriving (Show, Eq)++instance Enum TextSearchFlags where+    fromEnum TextSearchFlagsVisibleOnly = 1+    fromEnum TextSearchFlagsTextOnly = 2+    fromEnum TextSearchFlagsCaseInsensitive = 4+    fromEnum (AnotherTextSearchFlags k) = k++    toEnum 1 = TextSearchFlagsVisibleOnly+    toEnum 2 = TextSearchFlagsTextOnly+    toEnum 4 = TextSearchFlagsCaseInsensitive+    toEnum k = AnotherTextSearchFlags k++foreign import ccall "gtk_text_search_flags_get_type" c_gtk_text_search_flags_get_type :: +    IO GType++instance BoxedEnum TextSearchFlags where+    boxedEnumType _ = c_gtk_text_search_flags_get_type++instance IsGFlag TextSearchFlags++-- Flags TargetFlags++data TargetFlags = +      TargetFlagsSameApp+    | TargetFlagsSameWidget+    | TargetFlagsOtherApp+    | TargetFlagsOtherWidget+    | AnotherTargetFlags Int+    deriving (Show, Eq)++instance Enum TargetFlags where+    fromEnum TargetFlagsSameApp = 1+    fromEnum TargetFlagsSameWidget = 2+    fromEnum TargetFlagsOtherApp = 4+    fromEnum TargetFlagsOtherWidget = 8+    fromEnum (AnotherTargetFlags k) = k++    toEnum 1 = TargetFlagsSameApp+    toEnum 2 = TargetFlagsSameWidget+    toEnum 4 = TargetFlagsOtherApp+    toEnum 8 = TargetFlagsOtherWidget+    toEnum k = AnotherTargetFlags k++foreign import ccall "gtk_target_flags_get_type" c_gtk_target_flags_get_type :: +    IO GType++instance BoxedEnum TargetFlags where+    boxedEnumType _ = c_gtk_target_flags_get_type++instance IsGFlag TargetFlags++-- Flags StateFlags++data StateFlags = +      StateFlagsNormal+    | StateFlagsActive+    | StateFlagsPrelight+    | StateFlagsSelected+    | StateFlagsInsensitive+    | StateFlagsInconsistent+    | StateFlagsFocused+    | StateFlagsBackdrop+    | StateFlagsDirLtr+    | StateFlagsDirRtl+    | StateFlagsLink+    | StateFlagsVisited+    | StateFlagsChecked+    | AnotherStateFlags Int+    deriving (Show, Eq)++instance Enum StateFlags where+    fromEnum StateFlagsNormal = 0+    fromEnum StateFlagsActive = 1+    fromEnum StateFlagsPrelight = 2+    fromEnum StateFlagsSelected = 4+    fromEnum StateFlagsInsensitive = 8+    fromEnum StateFlagsInconsistent = 16+    fromEnum StateFlagsFocused = 32+    fromEnum StateFlagsBackdrop = 64+    fromEnum StateFlagsDirLtr = 128+    fromEnum StateFlagsDirRtl = 256+    fromEnum StateFlagsLink = 512+    fromEnum StateFlagsVisited = 1024+    fromEnum StateFlagsChecked = 2048+    fromEnum (AnotherStateFlags k) = k++    toEnum 0 = StateFlagsNormal+    toEnum 1 = StateFlagsActive+    toEnum 2 = StateFlagsPrelight+    toEnum 4 = StateFlagsSelected+    toEnum 8 = StateFlagsInsensitive+    toEnum 16 = StateFlagsInconsistent+    toEnum 32 = StateFlagsFocused+    toEnum 64 = StateFlagsBackdrop+    toEnum 128 = StateFlagsDirLtr+    toEnum 256 = StateFlagsDirRtl+    toEnum 512 = StateFlagsLink+    toEnum 1024 = StateFlagsVisited+    toEnum 2048 = StateFlagsChecked+    toEnum k = AnotherStateFlags k++foreign import ccall "gtk_state_flags_get_type" c_gtk_state_flags_get_type :: +    IO GType++instance BoxedEnum StateFlags where+    boxedEnumType _ = c_gtk_state_flags_get_type++instance IsGFlag StateFlags++-- Flags RegionFlags++data RegionFlags = +      RegionFlagsEven+    | RegionFlagsOdd+    | RegionFlagsFirst+    | RegionFlagsLast+    | RegionFlagsOnly+    | RegionFlagsSorted+    | AnotherRegionFlags Int+    deriving (Show, Eq)++instance Enum RegionFlags where+    fromEnum RegionFlagsEven = 1+    fromEnum RegionFlagsOdd = 2+    fromEnum RegionFlagsFirst = 4+    fromEnum RegionFlagsLast = 8+    fromEnum RegionFlagsOnly = 16+    fromEnum RegionFlagsSorted = 32+    fromEnum (AnotherRegionFlags k) = k++    toEnum 1 = RegionFlagsEven+    toEnum 2 = RegionFlagsOdd+    toEnum 4 = RegionFlagsFirst+    toEnum 8 = RegionFlagsLast+    toEnum 16 = RegionFlagsOnly+    toEnum 32 = RegionFlagsSorted+    toEnum k = AnotherRegionFlags k++foreign import ccall "gtk_region_flags_get_type" c_gtk_region_flags_get_type :: +    IO GType++instance BoxedEnum RegionFlags where+    boxedEnumType _ = c_gtk_region_flags_get_type++instance IsGFlag RegionFlags++-- Flags RecentFilterFlags++data RecentFilterFlags = +      RecentFilterFlagsUri+    | RecentFilterFlagsDisplayName+    | RecentFilterFlagsMimeType+    | RecentFilterFlagsApplication+    | RecentFilterFlagsGroup+    | RecentFilterFlagsAge+    | AnotherRecentFilterFlags Int+    deriving (Show, Eq)++instance Enum RecentFilterFlags where+    fromEnum RecentFilterFlagsUri = 1+    fromEnum RecentFilterFlagsDisplayName = 2+    fromEnum RecentFilterFlagsMimeType = 4+    fromEnum RecentFilterFlagsApplication = 8+    fromEnum RecentFilterFlagsGroup = 16+    fromEnum RecentFilterFlagsAge = 32+    fromEnum (AnotherRecentFilterFlags k) = k++    toEnum 1 = RecentFilterFlagsUri+    toEnum 2 = RecentFilterFlagsDisplayName+    toEnum 4 = RecentFilterFlagsMimeType+    toEnum 8 = RecentFilterFlagsApplication+    toEnum 16 = RecentFilterFlagsGroup+    toEnum 32 = RecentFilterFlagsAge+    toEnum k = AnotherRecentFilterFlags k++foreign import ccall "gtk_recent_filter_flags_get_type" c_gtk_recent_filter_flags_get_type :: +    IO GType++instance BoxedEnum RecentFilterFlags where+    boxedEnumType _ = c_gtk_recent_filter_flags_get_type++instance IsGFlag RecentFilterFlags++-- Flags RcFlags++data RcFlags = +      RcFlagsFg+    | RcFlagsBg+    | RcFlagsText+    | RcFlagsBase+    | AnotherRcFlags Int+    deriving (Show, Eq)++instance Enum RcFlags where+    fromEnum RcFlagsFg = 1+    fromEnum RcFlagsBg = 2+    fromEnum RcFlagsText = 4+    fromEnum RcFlagsBase = 8+    fromEnum (AnotherRcFlags k) = k++    toEnum 1 = RcFlagsFg+    toEnum 2 = RcFlagsBg+    toEnum 4 = RcFlagsText+    toEnum 8 = RcFlagsBase+    toEnum k = AnotherRcFlags k++foreign import ccall "gtk_rc_flags_get_type" c_gtk_rc_flags_get_type :: +    IO GType++instance BoxedEnum RcFlags where+    boxedEnumType _ = c_gtk_rc_flags_get_type++instance IsGFlag RcFlags++-- Flags PlacesOpenFlags++data PlacesOpenFlags = +      PlacesOpenFlagsNormal+    | PlacesOpenFlagsNewTab+    | PlacesOpenFlagsNewWindow+    | AnotherPlacesOpenFlags Int+    deriving (Show, Eq)++instance Enum PlacesOpenFlags where+    fromEnum PlacesOpenFlagsNormal = 1+    fromEnum PlacesOpenFlagsNewTab = 2+    fromEnum PlacesOpenFlagsNewWindow = 4+    fromEnum (AnotherPlacesOpenFlags k) = k++    toEnum 1 = PlacesOpenFlagsNormal+    toEnum 2 = PlacesOpenFlagsNewTab+    toEnum 4 = PlacesOpenFlagsNewWindow+    toEnum k = AnotherPlacesOpenFlags k++foreign import ccall "gtk_places_open_flags_get_type" c_gtk_places_open_flags_get_type :: +    IO GType++instance BoxedEnum PlacesOpenFlags where+    boxedEnumType _ = c_gtk_places_open_flags_get_type++instance IsGFlag PlacesOpenFlags++-- Flags JunctionSides++data JunctionSides = +      JunctionSidesNone+    | JunctionSidesCornerTopleft+    | JunctionSidesCornerTopright+    | JunctionSidesCornerBottomleft+    | JunctionSidesCornerBottomright+    | JunctionSidesTop+    | JunctionSidesBottom+    | JunctionSidesLeft+    | JunctionSidesRight+    | AnotherJunctionSides Int+    deriving (Show, Eq)++instance Enum JunctionSides where+    fromEnum JunctionSidesNone = 0+    fromEnum JunctionSidesCornerTopleft = 1+    fromEnum JunctionSidesCornerTopright = 2+    fromEnum JunctionSidesCornerBottomleft = 4+    fromEnum JunctionSidesCornerBottomright = 8+    fromEnum JunctionSidesTop = 3+    fromEnum JunctionSidesBottom = 12+    fromEnum JunctionSidesLeft = 5+    fromEnum JunctionSidesRight = 10+    fromEnum (AnotherJunctionSides k) = k++    toEnum 0 = JunctionSidesNone+    toEnum 1 = JunctionSidesCornerTopleft+    toEnum 2 = JunctionSidesCornerTopright+    toEnum 3 = JunctionSidesTop+    toEnum 4 = JunctionSidesCornerBottomleft+    toEnum 5 = JunctionSidesLeft+    toEnum 8 = JunctionSidesCornerBottomright+    toEnum 10 = JunctionSidesRight+    toEnum 12 = JunctionSidesBottom+    toEnum k = AnotherJunctionSides k++foreign import ccall "gtk_junction_sides_get_type" c_gtk_junction_sides_get_type :: +    IO GType++instance BoxedEnum JunctionSides where+    boxedEnumType _ = c_gtk_junction_sides_get_type++instance IsGFlag JunctionSides++-- Flags InputHints++data InputHints = +      InputHintsNone+    | InputHintsSpellcheck+    | InputHintsNoSpellcheck+    | InputHintsWordCompletion+    | InputHintsLowercase+    | InputHintsUppercaseChars+    | InputHintsUppercaseWords+    | InputHintsUppercaseSentences+    | InputHintsInhibitOsk+    | InputHintsVerticalWriting+    | AnotherInputHints Int+    deriving (Show, Eq)++instance Enum InputHints where+    fromEnum InputHintsNone = 0+    fromEnum InputHintsSpellcheck = 1+    fromEnum InputHintsNoSpellcheck = 2+    fromEnum InputHintsWordCompletion = 4+    fromEnum InputHintsLowercase = 8+    fromEnum InputHintsUppercaseChars = 16+    fromEnum InputHintsUppercaseWords = 32+    fromEnum InputHintsUppercaseSentences = 64+    fromEnum InputHintsInhibitOsk = 128+    fromEnum InputHintsVerticalWriting = 256+    fromEnum (AnotherInputHints k) = k++    toEnum 0 = InputHintsNone+    toEnum 1 = InputHintsSpellcheck+    toEnum 2 = InputHintsNoSpellcheck+    toEnum 4 = InputHintsWordCompletion+    toEnum 8 = InputHintsLowercase+    toEnum 16 = InputHintsUppercaseChars+    toEnum 32 = InputHintsUppercaseWords+    toEnum 64 = InputHintsUppercaseSentences+    toEnum 128 = InputHintsInhibitOsk+    toEnum 256 = InputHintsVerticalWriting+    toEnum k = AnotherInputHints k++foreign import ccall "gtk_input_hints_get_type" c_gtk_input_hints_get_type :: +    IO GType++instance BoxedEnum InputHints where+    boxedEnumType _ = c_gtk_input_hints_get_type++instance IsGFlag InputHints++-- Flags IconLookupFlags++data IconLookupFlags = +      IconLookupFlagsNoSvg+    | IconLookupFlagsForceSvg+    | IconLookupFlagsUseBuiltin+    | IconLookupFlagsGenericFallback+    | IconLookupFlagsForceSize+    | IconLookupFlagsForceRegular+    | IconLookupFlagsForceSymbolic+    | IconLookupFlagsDirLtr+    | IconLookupFlagsDirRtl+    | AnotherIconLookupFlags Int+    deriving (Show, Eq)++instance Enum IconLookupFlags where+    fromEnum IconLookupFlagsNoSvg = 1+    fromEnum IconLookupFlagsForceSvg = 2+    fromEnum IconLookupFlagsUseBuiltin = 4+    fromEnum IconLookupFlagsGenericFallback = 8+    fromEnum IconLookupFlagsForceSize = 16+    fromEnum IconLookupFlagsForceRegular = 32+    fromEnum IconLookupFlagsForceSymbolic = 64+    fromEnum IconLookupFlagsDirLtr = 128+    fromEnum IconLookupFlagsDirRtl = 256+    fromEnum (AnotherIconLookupFlags k) = k++    toEnum 1 = IconLookupFlagsNoSvg+    toEnum 2 = IconLookupFlagsForceSvg+    toEnum 4 = IconLookupFlagsUseBuiltin+    toEnum 8 = IconLookupFlagsGenericFallback+    toEnum 16 = IconLookupFlagsForceSize+    toEnum 32 = IconLookupFlagsForceRegular+    toEnum 64 = IconLookupFlagsForceSymbolic+    toEnum 128 = IconLookupFlagsDirLtr+    toEnum 256 = IconLookupFlagsDirRtl+    toEnum k = AnotherIconLookupFlags k++foreign import ccall "gtk_icon_lookup_flags_get_type" c_gtk_icon_lookup_flags_get_type :: +    IO GType++instance BoxedEnum IconLookupFlags where+    boxedEnumType _ = c_gtk_icon_lookup_flags_get_type++instance IsGFlag IconLookupFlags++-- Flags FileFilterFlags++data FileFilterFlags = +      FileFilterFlagsFilename+    | FileFilterFlagsUri+    | FileFilterFlagsDisplayName+    | FileFilterFlagsMimeType+    | AnotherFileFilterFlags Int+    deriving (Show, Eq)++instance Enum FileFilterFlags where+    fromEnum FileFilterFlagsFilename = 1+    fromEnum FileFilterFlagsUri = 2+    fromEnum FileFilterFlagsDisplayName = 4+    fromEnum FileFilterFlagsMimeType = 8+    fromEnum (AnotherFileFilterFlags k) = k++    toEnum 1 = FileFilterFlagsFilename+    toEnum 2 = FileFilterFlagsUri+    toEnum 4 = FileFilterFlagsDisplayName+    toEnum 8 = FileFilterFlagsMimeType+    toEnum k = AnotherFileFilterFlags k++foreign import ccall "gtk_file_filter_flags_get_type" c_gtk_file_filter_flags_get_type :: +    IO GType++instance BoxedEnum FileFilterFlags where+    boxedEnumType _ = c_gtk_file_filter_flags_get_type++instance IsGFlag FileFilterFlags++-- Flags DialogFlags++data DialogFlags = +      DialogFlagsModal+    | DialogFlagsDestroyWithParent+    | DialogFlagsUseHeaderBar+    | AnotherDialogFlags Int+    deriving (Show, Eq)++instance Enum DialogFlags where+    fromEnum DialogFlagsModal = 1+    fromEnum DialogFlagsDestroyWithParent = 2+    fromEnum DialogFlagsUseHeaderBar = 4+    fromEnum (AnotherDialogFlags k) = k++    toEnum 1 = DialogFlagsModal+    toEnum 2 = DialogFlagsDestroyWithParent+    toEnum 4 = DialogFlagsUseHeaderBar+    toEnum k = AnotherDialogFlags k++foreign import ccall "gtk_dialog_flags_get_type" c_gtk_dialog_flags_get_type :: +    IO GType++instance BoxedEnum DialogFlags where+    boxedEnumType _ = c_gtk_dialog_flags_get_type++instance IsGFlag DialogFlags++-- Flags DestDefaults++data DestDefaults = +      DestDefaultsMotion+    | DestDefaultsHighlight+    | DestDefaultsDrop+    | DestDefaultsAll+    | AnotherDestDefaults Int+    deriving (Show, Eq)++instance Enum DestDefaults where+    fromEnum DestDefaultsMotion = 1+    fromEnum DestDefaultsHighlight = 2+    fromEnum DestDefaultsDrop = 4+    fromEnum DestDefaultsAll = 7+    fromEnum (AnotherDestDefaults k) = k++    toEnum 1 = DestDefaultsMotion+    toEnum 2 = DestDefaultsHighlight+    toEnum 4 = DestDefaultsDrop+    toEnum 7 = DestDefaultsAll+    toEnum k = AnotherDestDefaults k++foreign import ccall "gtk_dest_defaults_get_type" c_gtk_dest_defaults_get_type :: +    IO GType++instance BoxedEnum DestDefaults where+    boxedEnumType _ = c_gtk_dest_defaults_get_type++instance IsGFlag DestDefaults++-- Flags DebugFlag++data DebugFlag = +      DebugFlagMisc+    | DebugFlagPlugsocket+    | DebugFlagText+    | DebugFlagTree+    | DebugFlagUpdates+    | DebugFlagKeybindings+    | DebugFlagMultihead+    | DebugFlagModules+    | DebugFlagGeometry+    | DebugFlagIcontheme+    | DebugFlagPrinting+    | DebugFlagBuilder+    | DebugFlagSizeRequest+    | DebugFlagNoCssCache+    | DebugFlagBaselines+    | DebugFlagPixelCache+    | DebugFlagNoPixelCache+    | DebugFlagInteractive+    | DebugFlagTouchscreen+    | DebugFlagActions+    | AnotherDebugFlag Int+    deriving (Show, Eq)++instance Enum DebugFlag where+    fromEnum DebugFlagMisc = 1+    fromEnum DebugFlagPlugsocket = 2+    fromEnum DebugFlagText = 4+    fromEnum DebugFlagTree = 8+    fromEnum DebugFlagUpdates = 16+    fromEnum DebugFlagKeybindings = 32+    fromEnum DebugFlagMultihead = 64+    fromEnum DebugFlagModules = 128+    fromEnum DebugFlagGeometry = 256+    fromEnum DebugFlagIcontheme = 512+    fromEnum DebugFlagPrinting = 1024+    fromEnum DebugFlagBuilder = 2048+    fromEnum DebugFlagSizeRequest = 4096+    fromEnum DebugFlagNoCssCache = 8192+    fromEnum DebugFlagBaselines = 16384+    fromEnum DebugFlagPixelCache = 32768+    fromEnum DebugFlagNoPixelCache = 65536+    fromEnum DebugFlagInteractive = 131072+    fromEnum DebugFlagTouchscreen = 262144+    fromEnum DebugFlagActions = 524288+    fromEnum (AnotherDebugFlag k) = k++    toEnum 1 = DebugFlagMisc+    toEnum 2 = DebugFlagPlugsocket+    toEnum 4 = DebugFlagText+    toEnum 8 = DebugFlagTree+    toEnum 16 = DebugFlagUpdates+    toEnum 32 = DebugFlagKeybindings+    toEnum 64 = DebugFlagMultihead+    toEnum 128 = DebugFlagModules+    toEnum 256 = DebugFlagGeometry+    toEnum 512 = DebugFlagIcontheme+    toEnum 1024 = DebugFlagPrinting+    toEnum 2048 = DebugFlagBuilder+    toEnum 4096 = DebugFlagSizeRequest+    toEnum 8192 = DebugFlagNoCssCache+    toEnum 16384 = DebugFlagBaselines+    toEnum 32768 = DebugFlagPixelCache+    toEnum 65536 = DebugFlagNoPixelCache+    toEnum 131072 = DebugFlagInteractive+    toEnum 262144 = DebugFlagTouchscreen+    toEnum 524288 = DebugFlagActions+    toEnum k = AnotherDebugFlag k++foreign import ccall "gtk_debug_flag_get_type" c_gtk_debug_flag_get_type :: +    IO GType++instance BoxedEnum DebugFlag where+    boxedEnumType _ = c_gtk_debug_flag_get_type++instance IsGFlag DebugFlag++-- Flags CellRendererState++data CellRendererState = +      CellRendererStateSelected+    | CellRendererStatePrelit+    | CellRendererStateInsensitive+    | CellRendererStateSorted+    | CellRendererStateFocused+    | CellRendererStateExpandable+    | CellRendererStateExpanded+    | AnotherCellRendererState Int+    deriving (Show, Eq)++instance Enum CellRendererState where+    fromEnum CellRendererStateSelected = 1+    fromEnum CellRendererStatePrelit = 2+    fromEnum CellRendererStateInsensitive = 4+    fromEnum CellRendererStateSorted = 8+    fromEnum CellRendererStateFocused = 16+    fromEnum CellRendererStateExpandable = 32+    fromEnum CellRendererStateExpanded = 64+    fromEnum (AnotherCellRendererState k) = k++    toEnum 1 = CellRendererStateSelected+    toEnum 2 = CellRendererStatePrelit+    toEnum 4 = CellRendererStateInsensitive+    toEnum 8 = CellRendererStateSorted+    toEnum 16 = CellRendererStateFocused+    toEnum 32 = CellRendererStateExpandable+    toEnum 64 = CellRendererStateExpanded+    toEnum k = AnotherCellRendererState k++foreign import ccall "gtk_cell_renderer_state_get_type" c_gtk_cell_renderer_state_get_type :: +    IO GType++instance BoxedEnum CellRendererState where+    boxedEnumType _ = c_gtk_cell_renderer_state_get_type++instance IsGFlag CellRendererState++-- Flags CalendarDisplayOptions++data CalendarDisplayOptions = +      CalendarDisplayOptionsShowHeading+    | CalendarDisplayOptionsShowDayNames+    | CalendarDisplayOptionsNoMonthChange+    | CalendarDisplayOptionsShowWeekNumbers+    | CalendarDisplayOptionsShowDetails+    | AnotherCalendarDisplayOptions Int+    deriving (Show, Eq)++instance Enum CalendarDisplayOptions where+    fromEnum CalendarDisplayOptionsShowHeading = 1+    fromEnum CalendarDisplayOptionsShowDayNames = 2+    fromEnum CalendarDisplayOptionsNoMonthChange = 4+    fromEnum CalendarDisplayOptionsShowWeekNumbers = 8+    fromEnum CalendarDisplayOptionsShowDetails = 32+    fromEnum (AnotherCalendarDisplayOptions k) = k++    toEnum 1 = CalendarDisplayOptionsShowHeading+    toEnum 2 = CalendarDisplayOptionsShowDayNames+    toEnum 4 = CalendarDisplayOptionsNoMonthChange+    toEnum 8 = CalendarDisplayOptionsShowWeekNumbers+    toEnum 32 = CalendarDisplayOptionsShowDetails+    toEnum k = AnotherCalendarDisplayOptions k++foreign import ccall "gtk_calendar_display_options_get_type" c_gtk_calendar_display_options_get_type :: +    IO GType++instance BoxedEnum CalendarDisplayOptions where+    boxedEnumType _ = c_gtk_calendar_display_options_get_type++instance IsGFlag CalendarDisplayOptions++-- Flags AttachOptions++data AttachOptions = +      AttachOptionsExpand+    | AttachOptionsShrink+    | AttachOptionsFill+    | AnotherAttachOptions Int+    deriving (Show, Eq)++instance Enum AttachOptions where+    fromEnum AttachOptionsExpand = 1+    fromEnum AttachOptionsShrink = 2+    fromEnum AttachOptionsFill = 4+    fromEnum (AnotherAttachOptions k) = k++    toEnum 1 = AttachOptionsExpand+    toEnum 2 = AttachOptionsShrink+    toEnum 4 = AttachOptionsFill+    toEnum k = AnotherAttachOptions k++foreign import ccall "gtk_attach_options_get_type" c_gtk_attach_options_get_type :: +    IO GType++instance BoxedEnum AttachOptions where+    boxedEnumType _ = c_gtk_attach_options_get_type++instance IsGFlag AttachOptions++-- Flags ApplicationInhibitFlags++data ApplicationInhibitFlags = +      ApplicationInhibitFlagsLogout+    | ApplicationInhibitFlagsSwitch+    | ApplicationInhibitFlagsSuspend+    | ApplicationInhibitFlagsIdle+    | AnotherApplicationInhibitFlags Int+    deriving (Show, Eq)++instance Enum ApplicationInhibitFlags where+    fromEnum ApplicationInhibitFlagsLogout = 1+    fromEnum ApplicationInhibitFlagsSwitch = 2+    fromEnum ApplicationInhibitFlagsSuspend = 4+    fromEnum ApplicationInhibitFlagsIdle = 8+    fromEnum (AnotherApplicationInhibitFlags k) = k++    toEnum 1 = ApplicationInhibitFlagsLogout+    toEnum 2 = ApplicationInhibitFlagsSwitch+    toEnum 4 = ApplicationInhibitFlagsSuspend+    toEnum 8 = ApplicationInhibitFlagsIdle+    toEnum k = AnotherApplicationInhibitFlags k++foreign import ccall "gtk_application_inhibit_flags_get_type" c_gtk_application_inhibit_flags_get_type :: +    IO GType++instance BoxedEnum ApplicationInhibitFlags where+    boxedEnumType _ = c_gtk_application_inhibit_flags_get_type++instance IsGFlag ApplicationInhibitFlags++-- Flags AccelFlags++data AccelFlags = +      AccelFlagsVisible+    | AccelFlagsLocked+    | AccelFlagsMask+    | AnotherAccelFlags Int+    deriving (Show, Eq)++instance Enum AccelFlags where+    fromEnum AccelFlagsVisible = 1+    fromEnum AccelFlagsLocked = 2+    fromEnum AccelFlagsMask = 7+    fromEnum (AnotherAccelFlags k) = k++    toEnum 1 = AccelFlagsVisible+    toEnum 2 = AccelFlagsLocked+    toEnum 7 = AccelFlagsMask+    toEnum k = AnotherAccelFlags k++foreign import ccall "gtk_accel_flags_get_type" c_gtk_accel_flags_get_type :: +    IO GType++instance BoxedEnum AccelFlags where+    boxedEnumType _ = c_gtk_accel_flags_get_type++instance IsGFlag AccelFlags++
+ GI/Gtk/Functions.hs view
@@ -0,0 +1,6860 @@++{- |+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.Gtk.Functions+    ( ++ -- * Methods+-- ** accelGroupsActivate+    accelGroupsActivate                     ,+++-- ** accelGroupsFromObject+    accelGroupsFromObject                   ,+++-- ** acceleratorGetDefaultModMask+    acceleratorGetDefaultModMask            ,+++-- ** acceleratorGetLabel+    acceleratorGetLabel                     ,+++-- ** acceleratorGetLabelWithKeycode+    acceleratorGetLabelWithKeycode          ,+++-- ** acceleratorName+    acceleratorName                         ,+++-- ** acceleratorNameWithKeycode+    acceleratorNameWithKeycode              ,+++-- ** acceleratorParse+    acceleratorParse                        ,+++-- ** acceleratorParseWithKeycode+    acceleratorParseWithKeycode             ,+++-- ** acceleratorSetDefaultModMask+    acceleratorSetDefaultModMask            ,+++-- ** acceleratorValid+    acceleratorValid                        ,+++-- ** alternativeDialogButtonOrder+    alternativeDialogButtonOrder            ,+++-- ** bindingEntryAddSignalFromString+    bindingEntryAddSignalFromString         ,+++-- ** bindingEntryAddSignall+    bindingEntryAddSignall                  ,+++-- ** bindingEntryRemove+    bindingEntryRemove                      ,+++-- ** bindingEntrySkip+    bindingEntrySkip                        ,+++-- ** bindingSetFind+    bindingSetFind                          ,+++-- ** bindingsActivate+    bindingsActivate                        ,+++-- ** bindingsActivateEvent+    bindingsActivateEvent                   ,+++-- ** builderErrorQuark+    builderErrorQuark                       ,+++-- ** cairoShouldDrawWindow+    cairoShouldDrawWindow                   ,+++-- ** cairoTransformToWindow+    cairoTransformToWindow                  ,+++-- ** checkVersion+    checkVersion                            ,+++-- ** cssProviderErrorQuark+    cssProviderErrorQuark                   ,+++-- ** deviceGrabAdd+    deviceGrabAdd                           ,+++-- ** deviceGrabRemove+    deviceGrabRemove                        ,+++-- ** disableSetlocale+    disableSetlocale                        ,+++-- ** distributeNaturalAllocation+    distributeNaturalAllocation             ,+++-- ** dragCancel+    dragCancel                              ,+++-- ** dragFinish+    dragFinish                              ,+++-- ** dragGetSourceWidget+    dragGetSourceWidget                     ,+++-- ** dragSetIconDefault+    dragSetIconDefault                      ,+++-- ** dragSetIconGicon+    dragSetIconGicon                        ,+++-- ** dragSetIconName+    dragSetIconName                         ,+++-- ** dragSetIconPixbuf+    dragSetIconPixbuf                       ,+++-- ** dragSetIconStock+    dragSetIconStock                        ,+++-- ** dragSetIconSurface+    dragSetIconSurface                      ,+++-- ** dragSetIconWidget+    dragSetIconWidget                       ,+++-- ** drawInsertionCursor+    drawInsertionCursor                     ,+++-- ** eventsPending+    eventsPending                           ,+++-- ** false+    false                                   ,+++-- ** fileChooserErrorQuark+    fileChooserErrorQuark                   ,+++-- ** getBinaryAge+    getBinaryAge                            ,+++-- ** getCurrentEvent+    getCurrentEvent                         ,+++-- ** getCurrentEventDevice+    getCurrentEventDevice                   ,+++-- ** getCurrentEventState+    getCurrentEventState                    ,+++-- ** getCurrentEventTime+    getCurrentEventTime                     ,+++-- ** getDebugFlags+    getDebugFlags                           ,+++-- ** getDefaultLanguage+    getDefaultLanguage                      ,+++-- ** getEventWidget+    getEventWidget                          ,+++-- ** getInterfaceAge+    getInterfaceAge                         ,+++-- ** getLocaleDirection+    getLocaleDirection                      ,+++-- ** getMajorVersion+    getMajorVersion                         ,+++-- ** getMicroVersion+    getMicroVersion                         ,+++-- ** getMinorVersion+    getMinorVersion                         ,+++-- ** getOptionGroup+    getOptionGroup                          ,+++-- ** grabGetCurrent+    grabGetCurrent                          ,+++-- ** iconSizeFromName+    iconSizeFromName                        ,+++-- ** iconSizeGetName+    iconSizeGetName                         ,+++-- ** iconSizeLookup+    iconSizeLookup                          ,+++-- ** iconSizeLookupForSettings+    iconSizeLookupForSettings               ,+++-- ** iconSizeRegister+    iconSizeRegister                        ,+++-- ** iconSizeRegisterAlias+    iconSizeRegisterAlias                   ,+++-- ** iconThemeErrorQuark+    iconThemeErrorQuark                     ,+++-- ** init+    init                                    ,+++-- ** initCheck+    initCheck                               ,+++-- ** initWithArgs+    initWithArgs                            ,+++-- ** keySnooperRemove+    keySnooperRemove                        ,+++-- ** main+    main                                    ,+++-- ** mainDoEvent+    mainDoEvent                             ,+++-- ** mainIteration+    mainIteration                           ,+++-- ** mainIterationDo+    mainIterationDo                         ,+++-- ** mainLevel+    mainLevel                               ,+++-- ** mainQuit+    mainQuit                                ,+++-- ** paintArrow+    paintArrow                              ,+++-- ** paintBox+    paintBox                                ,+++-- ** paintBoxGap+    paintBoxGap                             ,+++-- ** paintCheck+    paintCheck                              ,+++-- ** paintDiamond+    paintDiamond                            ,+++-- ** paintExpander+    paintExpander                           ,+++-- ** paintExtension+    paintExtension                          ,+++-- ** paintFlatBox+    paintFlatBox                            ,+++-- ** paintFocus+    paintFocus                              ,+++-- ** paintHandle+    paintHandle                             ,+++-- ** paintHline+    paintHline                              ,+++-- ** paintLayout+    paintLayout                             ,+++-- ** paintOption+    paintOption                             ,+++-- ** paintResizeGrip+    paintResizeGrip                         ,+++-- ** paintShadow+    paintShadow                             ,+++-- ** paintShadowGap+    paintShadowGap                          ,+++-- ** paintSlider+    paintSlider                             ,+++-- ** paintSpinner+    paintSpinner                            ,+++-- ** paintTab+    paintTab                                ,+++-- ** paintVline+    paintVline                              ,+++-- ** paperSizeGetDefault+    paperSizeGetDefault                     ,+++-- ** paperSizeGetPaperSizes+    paperSizeGetPaperSizes                  ,+++-- ** parseArgs+    parseArgs                               ,+++-- ** printErrorQuark+    printErrorQuark                         ,+++-- ** printRunPageSetupDialog+    printRunPageSetupDialog                 ,+++-- ** printRunPageSetupDialogAsync+    printRunPageSetupDialogAsync            ,+++-- ** propagateEvent+    propagateEvent                          ,+++-- ** rcAddDefaultFile+    rcAddDefaultFile                        ,+++-- ** rcFindModuleInPath+    rcFindModuleInPath                      ,+++-- ** rcFindPixmapInPath+    rcFindPixmapInPath                      ,+++-- ** rcGetDefaultFiles+    rcGetDefaultFiles                       ,+++-- ** rcGetImModuleFile+    rcGetImModuleFile                       ,+++-- ** rcGetImModulePath+    rcGetImModulePath                       ,+++-- ** rcGetModuleDir+    rcGetModuleDir                          ,+++-- ** rcGetStyle+    rcGetStyle                              ,+++-- ** rcGetStyleByPaths+    rcGetStyleByPaths                       ,+++-- ** rcGetThemeDir+    rcGetThemeDir                           ,+++-- ** rcParse+    rcParse                                 ,+++-- ** rcParseColor+    rcParseColor                            ,+++-- ** rcParseColorFull+    rcParseColorFull                        ,+++-- ** rcParsePriority+    rcParsePriority                         ,+++-- ** rcParseState+    rcParseState                            ,+++-- ** rcParseString+    rcParseString                           ,+++-- ** rcPropertyParseBorder+    rcPropertyParseBorder                   ,+++-- ** rcPropertyParseColor+    rcPropertyParseColor                    ,+++-- ** rcPropertyParseEnum+    rcPropertyParseEnum                     ,+++-- ** rcPropertyParseFlags+    rcPropertyParseFlags                    ,+++-- ** rcPropertyParseRequisition+    rcPropertyParseRequisition              ,+++-- ** rcReparseAll+    rcReparseAll                            ,+++-- ** rcReparseAllForSettings+    rcReparseAllForSettings                 ,+++-- ** rcResetStyles+    rcResetStyles                           ,+++-- ** rcSetDefaultFiles+    rcSetDefaultFiles                       ,+++-- ** recentChooserErrorQuark+    recentChooserErrorQuark                 ,+++-- ** recentManagerErrorQuark+    recentManagerErrorQuark                 ,+++-- ** renderActivity+    renderActivity                          ,+++-- ** renderArrow+    renderArrow                             ,+++-- ** renderBackground+    renderBackground                        ,+++-- ** renderCheck+    renderCheck                             ,+++-- ** renderExpander+    renderExpander                          ,+++-- ** renderExtension+    renderExtension                         ,+++-- ** renderFocus+    renderFocus                             ,+++-- ** renderFrame+    renderFrame                             ,+++-- ** renderFrameGap+    renderFrameGap                          ,+++-- ** renderHandle+    renderHandle                            ,+++-- ** renderIcon+    renderIcon                              ,+++-- ** renderIconPixbuf+    renderIconPixbuf                        ,+++-- ** renderIconSurface+    renderIconSurface                       ,+++-- ** renderInsertionCursor+    renderInsertionCursor                   ,+++-- ** renderLayout+    renderLayout                            ,+++-- ** renderLine+    renderLine                              ,+++-- ** renderOption+    renderOption                            ,+++-- ** renderSlider+    renderSlider                            ,+++-- ** rgbToHsv+    rgbToHsv                                ,+++-- ** selectionAddTarget+    selectionAddTarget                      ,+++-- ** selectionAddTargets+    selectionAddTargets                     ,+++-- ** selectionClearTargets+    selectionClearTargets                   ,+++-- ** selectionConvert+    selectionConvert                        ,+++-- ** selectionOwnerSet+    selectionOwnerSet                       ,+++-- ** selectionOwnerSetForDisplay+    selectionOwnerSetForDisplay             ,+++-- ** selectionRemoveAll+    selectionRemoveAll                      ,+++-- ** setDebugFlags+    setDebugFlags                           ,+++-- ** showUri+    showUri                                 ,+++-- ** stockAdd+    stockAdd                                ,+++-- ** stockAddStatic+    stockAddStatic                          ,+++-- ** stockListIds+    stockListIds                            ,+++-- ** stockLookup+    stockLookup                             ,+++-- ** stockSetTranslateFunc+    stockSetTranslateFunc                   ,+++-- ** targetTableFree+    targetTableFree                         ,+++-- ** targetTableNewFromList+    targetTableNewFromList                  ,+++-- ** targetsIncludeImage+    targetsIncludeImage                     ,+++-- ** targetsIncludeRichText+    targetsIncludeRichText                  ,+++-- ** targetsIncludeText+    targetsIncludeText                      ,+++-- ** targetsIncludeUri+    targetsIncludeUri                       ,+++-- ** testCreateSimpleWindow+    testCreateSimpleWindow                  ,+++-- ** testFindLabel+    testFindLabel                           ,+++-- ** testFindSibling+    testFindSibling                         ,+++-- ** testFindWidget+    testFindWidget                          ,+++-- ** testListAllTypes+    testListAllTypes                        ,+++-- ** testRegisterAllTypes+    testRegisterAllTypes                    ,+++-- ** testSliderGetValue+    testSliderGetValue                      ,+++-- ** testSliderSetPerc+    testSliderSetPerc                       ,+++-- ** testSpinButtonClick+    testSpinButtonClick                     ,+++-- ** testTextGet+    testTextGet                             ,+++-- ** testTextSet+    testTextSet                             ,+++-- ** testWidgetClick+    testWidgetClick                         ,+++-- ** testWidgetSendKey+    testWidgetSendKey                       ,+++-- ** testWidgetWaitForDraw+    testWidgetWaitForDraw                   ,+++-- ** treeGetRowDragData+    treeGetRowDragData                      ,+++-- ** treeRowReferenceDeleted+    treeRowReferenceDeleted                 ,+++-- ** treeRowReferenceInserted+    treeRowReferenceInserted                ,+++-- ** treeSetRowDragData+    treeSetRowDragData                      ,+++-- ** true+    true                                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Pango as Pango+import qualified GI.Cairo as Cairo++-- function gtk_true+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_true" gtk_true :: +    IO CInt+++true ::+    (MonadIO m) =>+    m Bool+true  = liftIO $ do+    result <- gtk_true+    let result' = (/= 0) result+    return result'+++-- function gtk_tree_set_row_drag_data+-- Args : [Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tree_model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tree_model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_set_row_drag_data" gtk_tree_set_row_drag_data :: +    Ptr SelectionData ->                    -- selection_data : TInterface "Gtk" "SelectionData"+    Ptr TreeModel ->                        -- tree_model : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO CInt+++treeSetRowDragData ::+    (MonadIO m, TreeModelK a) =>+    SelectionData ->                        -- selection_data+    a ->                                    -- tree_model+    TreePath ->                             -- path+    m Bool+treeSetRowDragData selection_data tree_model path = liftIO $ do+    let selection_data' = unsafeManagedPtrGetPtr selection_data+    let tree_model' = unsafeManagedPtrCastPtr tree_model+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_tree_set_row_drag_data selection_data' tree_model' path'+    let result' = (/= 0) result+    touchManagedPtr selection_data+    touchManagedPtr tree_model+    touchManagedPtr path+    return result'+++-- function gtk_tree_row_reference_inserted+-- Args : [Arg {argName = "proxy", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "proxy", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_row_reference_inserted" gtk_tree_row_reference_inserted :: +    Ptr GObject.Object ->                   -- proxy : TInterface "GObject" "Object"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++treeRowReferenceInserted ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- proxy+    TreePath ->                             -- path+    m ()+treeRowReferenceInserted proxy path = liftIO $ do+    let proxy' = unsafeManagedPtrCastPtr proxy+    let path' = unsafeManagedPtrGetPtr path+    gtk_tree_row_reference_inserted proxy' path'+    touchManagedPtr proxy+    touchManagedPtr path+    return ()+++-- function gtk_tree_row_reference_deleted+-- Args : [Arg {argName = "proxy", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "proxy", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_row_reference_deleted" gtk_tree_row_reference_deleted :: +    Ptr GObject.Object ->                   -- proxy : TInterface "GObject" "Object"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++treeRowReferenceDeleted ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- proxy+    TreePath ->                             -- path+    m ()+treeRowReferenceDeleted proxy path = liftIO $ do+    let proxy' = unsafeManagedPtrCastPtr proxy+    let path' = unsafeManagedPtrGetPtr path+    gtk_tree_row_reference_deleted proxy' path'+    touchManagedPtr proxy+    touchManagedPtr path+    return ()+++-- function gtk_tree_get_row_drag_data+-- Args : [Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tree_model", argType = TInterface "Gtk" "TreeModel", direction = DirectionOut, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_get_row_drag_data" gtk_tree_get_row_drag_data :: +    Ptr SelectionData ->                    -- selection_data : TInterface "Gtk" "SelectionData"+    Ptr (Ptr TreeModel) ->                  -- tree_model : TInterface "Gtk" "TreeModel"+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    IO CInt+++treeGetRowDragData ::+    (MonadIO m) =>+    SelectionData ->                        -- selection_data+    m (Bool,(Maybe TreeModel),(Maybe TreePath))+treeGetRowDragData selection_data = liftIO $ do+    let selection_data' = unsafeManagedPtrGetPtr selection_data+    tree_model <- allocMem :: IO (Ptr (Ptr TreeModel))+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    result <- gtk_tree_get_row_drag_data selection_data' tree_model path+    let result' = (/= 0) result+    tree_model' <- peek tree_model+    maybeTree_model' <- convertIfNonNull tree_model' $ \tree_model'' -> do+        tree_model''' <- (newObject TreeModel) tree_model''+        return tree_model'''+    path' <- peek path+    maybePath' <- convertIfNonNull path' $ \path'' -> do+        path''' <- (wrapBoxed TreePath) path''+        return path'''+    touchManagedPtr selection_data+    freeMem tree_model+    freeMem path+    return (result', maybeTree_model', maybePath')+++-- function gtk_test_widget_wait_for_draw+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_widget_wait_for_draw" gtk_test_widget_wait_for_draw :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++testWidgetWaitForDraw ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m ()+testWidgetWaitForDraw widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_test_widget_wait_for_draw widget'+    touchManagedPtr widget+    return ()+++-- function gtk_test_widget_send_key+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_widget_send_key" gtk_test_widget_send_key :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO CInt+++testWidgetSendKey ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    m Bool+testWidgetSendKey widget keyval modifiers = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let modifiers' = gflagsToWord modifiers+    result <- gtk_test_widget_send_key widget' keyval modifiers'+    let result' = (/= 0) result+    touchManagedPtr widget+    return result'+++-- function gtk_test_widget_click+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_widget_click" gtk_test_widget_click :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Word32 ->                               -- button : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO CInt+++testWidgetClick ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Word32 ->                               -- button+    [Gdk.ModifierType] ->                   -- modifiers+    m Bool+testWidgetClick widget button modifiers = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let modifiers' = gflagsToWord modifiers+    result <- gtk_test_widget_click widget' button modifiers'+    let result' = (/= 0) result+    touchManagedPtr widget+    return result'+++-- function gtk_test_text_set+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", 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 "gtk_test_text_set" gtk_test_text_set :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- string : TBasicType TUTF8+    IO ()+++testTextSet ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    T.Text ->                               -- string+    m ()+testTextSet widget string = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    string' <- textToCString string+    gtk_test_text_set widget' string'+    touchManagedPtr widget+    freeMem string'+    return ()+++-- function gtk_test_text_get+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_text_get" gtk_test_text_get :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO CString+++testTextGet ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m T.Text+testTextGet widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_test_text_get widget'+    checkUnexpectedReturnNULL "gtk_test_text_get" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr widget+    return result'+++-- function gtk_test_spin_button_click+-- Args : [Arg {argName = "spinner", argType = TInterface "Gtk" "SpinButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upwards", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "spinner", argType = TInterface "Gtk" "SpinButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upwards", 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 "gtk_test_spin_button_click" gtk_test_spin_button_click :: +    Ptr SpinButton ->                       -- spinner : TInterface "Gtk" "SpinButton"+    Word32 ->                               -- button : TBasicType TUInt32+    CInt ->                                 -- upwards : TBasicType TBoolean+    IO CInt+++testSpinButtonClick ::+    (MonadIO m, SpinButtonK a) =>+    a ->                                    -- spinner+    Word32 ->                               -- button+    Bool ->                                 -- upwards+    m Bool+testSpinButtonClick spinner button upwards = liftIO $ do+    let spinner' = unsafeManagedPtrCastPtr spinner+    let upwards' = (fromIntegral . fromEnum) upwards+    result <- gtk_test_spin_button_click spinner' button upwards'+    let result' = (/= 0) result+    touchManagedPtr spinner+    return result'+++-- function gtk_test_slider_set_perc+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "percentage", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "percentage", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_slider_set_perc" gtk_test_slider_set_perc :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CDouble ->                              -- percentage : TBasicType TDouble+    IO ()+++testSliderSetPerc ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Double ->                               -- percentage+    m ()+testSliderSetPerc widget percentage = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let percentage' = realToFrac percentage+    gtk_test_slider_set_perc widget' percentage'+    touchManagedPtr widget+    return ()+++-- function gtk_test_slider_get_value+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_slider_get_value" gtk_test_slider_get_value :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO CDouble+++testSliderGetValue ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m Double+testSliderGetValue widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_test_slider_get_value widget'+    let result' = realToFrac result+    touchManagedPtr widget+    return result'+++-- function gtk_test_register_all_types+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_register_all_types" gtk_test_register_all_types :: +    IO ()+++testRegisterAllTypes ::+    (MonadIO m) =>+    m ()+testRegisterAllTypes  = liftIO $ do+    gtk_test_register_all_types+    return ()+++-- function gtk_test_list_all_types+-- Args : [Arg {argName = "n_types", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : []+-- returnType : TCArray True (-1) 0 (TBasicType TGType)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_list_all_types" gtk_test_list_all_types :: +    Ptr Word32 ->                           -- n_types : TBasicType TUInt32+    IO (Ptr CGType)+++testListAllTypes ::+    (MonadIO m) =>+    m ([GType],Word32)+testListAllTypes  = liftIO $ do+    n_types <- allocMem :: IO (Ptr Word32)+    result <- gtk_test_list_all_types n_types+    checkUnexpectedReturnNULL "gtk_test_list_all_types" result+    result' <- (unpackMapZeroTerminatedStorableArray GType) result+    n_types' <- peek n_types+    freeMem n_types+    return (result', n_types')+++-- function gtk_test_find_widget+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_find_widget" gtk_test_find_widget :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- label_pattern : TBasicType TUTF8+    CGType ->                               -- widget_type : TBasicType TGType+    IO (Ptr Widget)+++testFindWidget ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    T.Text ->                               -- label_pattern+    GType ->                                -- widget_type+    m Widget+testFindWidget widget label_pattern widget_type = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    label_pattern' <- textToCString label_pattern+    let widget_type' = gtypeToCGType widget_type+    result <- gtk_test_find_widget widget' label_pattern' widget_type'+    checkUnexpectedReturnNULL "gtk_test_find_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr widget+    freeMem label_pattern'+    return result'+++-- function gtk_test_find_sibling+-- Args : [Arg {argName = "base_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_find_sibling" gtk_test_find_sibling :: +    Ptr Widget ->                           -- base_widget : TInterface "Gtk" "Widget"+    CGType ->                               -- widget_type : TBasicType TGType+    IO (Ptr Widget)+++testFindSibling ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- base_widget+    GType ->                                -- widget_type+    m Widget+testFindSibling base_widget widget_type = liftIO $ do+    let base_widget' = unsafeManagedPtrCastPtr base_widget+    let widget_type' = gtypeToCGType widget_type+    result <- gtk_test_find_sibling base_widget' widget_type'+    checkUnexpectedReturnNULL "gtk_test_find_sibling" result+    result' <- (newObject Widget) result+    touchManagedPtr base_widget+    return result'+++-- function gtk_test_find_label+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_find_label" gtk_test_find_label :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- label_pattern : TBasicType TUTF8+    IO (Ptr Widget)+++testFindLabel ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    T.Text ->                               -- label_pattern+    m Widget+testFindLabel widget label_pattern = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    label_pattern' <- textToCString label_pattern+    result <- gtk_test_find_label widget' label_pattern'+    checkUnexpectedReturnNULL "gtk_test_find_label" result+    result' <- (newObject Widget) result+    touchManagedPtr widget+    freeMem label_pattern'+    return result'+++-- function gtk_test_create_simple_window+-- Args : [Arg {argName = "window_title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dialog_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "window_title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dialog_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_test_create_simple_window" gtk_test_create_simple_window :: +    CString ->                              -- window_title : TBasicType TUTF8+    CString ->                              -- dialog_text : TBasicType TUTF8+    IO (Ptr Widget)+++testCreateSimpleWindow ::+    (MonadIO m) =>+    T.Text ->                               -- window_title+    T.Text ->                               -- dialog_text+    m Widget+testCreateSimpleWindow window_title dialog_text = liftIO $ do+    window_title' <- textToCString window_title+    dialog_text' <- textToCString dialog_text+    result <- gtk_test_create_simple_window window_title' dialog_text'+    checkUnexpectedReturnNULL "gtk_test_create_simple_window" result+    result' <- (newObject Widget) result+    freeMem window_title'+    freeMem dialog_text'+    return result'+++-- function gtk_targets_include_uri+-- Args : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_targets_include_uri" gtk_targets_include_uri :: +    Ptr (Ptr Gdk.Atom) ->                   -- targets : TCArray False (-1) 1 (TInterface "Gdk" "Atom")+    Int32 ->                                -- n_targets : TBasicType TInt32+    IO CInt+++targetsIncludeUri ::+    (MonadIO m) =>+    [Gdk.Atom] ->                           -- targets+    m Bool+targetsIncludeUri targets = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packPtrArray targets'+    result <- gtk_targets_include_uri targets'' n_targets+    let result' = (/= 0) result+    mapM_ touchManagedPtr targets+    freeMem targets''+    return result'+++-- function gtk_targets_include_text+-- Args : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_targets_include_text" gtk_targets_include_text :: +    Ptr (Ptr Gdk.Atom) ->                   -- targets : TCArray False (-1) 1 (TInterface "Gdk" "Atom")+    Int32 ->                                -- n_targets : TBasicType TInt32+    IO CInt+++targetsIncludeText ::+    (MonadIO m) =>+    [Gdk.Atom] ->                           -- targets+    m Bool+targetsIncludeText targets = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packPtrArray targets'+    result <- gtk_targets_include_text targets'' n_targets+    let result' = (/= 0) result+    mapM_ touchManagedPtr targets+    freeMem targets''+    return result'+++-- function gtk_targets_include_rich_text+-- Args : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_targets_include_rich_text" gtk_targets_include_rich_text :: +    Ptr (Ptr Gdk.Atom) ->                   -- targets : TCArray False (-1) 1 (TInterface "Gdk" "Atom")+    Int32 ->                                -- n_targets : TBasicType TInt32+    Ptr TextBuffer ->                       -- buffer : TInterface "Gtk" "TextBuffer"+    IO CInt+++targetsIncludeRichText ::+    (MonadIO m, TextBufferK a) =>+    [Gdk.Atom] ->                           -- targets+    a ->                                    -- buffer+    m Bool+targetsIncludeRichText targets buffer = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packPtrArray targets'+    let buffer' = unsafeManagedPtrCastPtr buffer+    result <- gtk_targets_include_rich_text targets'' n_targets buffer'+    let result' = (/= 0) result+    mapM_ touchManagedPtr targets+    touchManagedPtr buffer+    freeMem targets''+    return result'+++-- function gtk_targets_include_image+-- Args : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "writable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gdk" "Atom"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "writable", 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 "gtk_targets_include_image" gtk_targets_include_image :: +    Ptr (Ptr Gdk.Atom) ->                   -- targets : TCArray False (-1) 1 (TInterface "Gdk" "Atom")+    Int32 ->                                -- n_targets : TBasicType TInt32+    CInt ->                                 -- writable : TBasicType TBoolean+    IO CInt+++targetsIncludeImage ::+    (MonadIO m) =>+    [Gdk.Atom] ->                           -- targets+    Bool ->                                 -- writable+    m Bool+targetsIncludeImage targets writable = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packPtrArray targets'+    let writable' = (fromIntegral . fromEnum) writable+    result <- gtk_targets_include_image targets'' n_targets writable'+    let result' = (/= 0) result+    mapM_ touchManagedPtr targets+    freeMem targets''+    return result'+++-- function gtk_target_table_new_from_list+-- Args : [Arg {argName = "list", argType = TInterface "Gtk" "TargetList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "list", argType = TInterface "Gtk" "TargetList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TInterface "Gtk" "TargetEntry")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_target_table_new_from_list" gtk_target_table_new_from_list :: +    Ptr TargetList ->                       -- list : TInterface "Gtk" "TargetList"+    Ptr Int32 ->                            -- n_targets : TBasicType TInt32+    IO (Ptr TargetEntry)+++targetTableNewFromList ::+    (MonadIO m) =>+    TargetList ->                           -- list+    m [TargetEntry]+targetTableNewFromList list = liftIO $ do+    let list' = unsafeManagedPtrGetPtr list+    n_targets <- allocMem :: IO (Ptr Int32)+    result <- gtk_target_table_new_from_list list' n_targets+    n_targets' <- peek n_targets+    checkUnexpectedReturnNULL "gtk_target_table_new_from_list" result+    result' <- (unpackBoxedArrayWithLength 16 n_targets') result+    result'' <- mapM (wrapBoxed TargetEntry) result'+    freeMem result+    touchManagedPtr list+    freeMem n_targets+    return result''+++-- function gtk_target_table_free+-- Args : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "targets", argType = TCArray False (-1) 1 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_target_table_free" gtk_target_table_free :: +    Ptr TargetEntry ->                      -- targets : TCArray False (-1) 1 (TInterface "Gtk" "TargetEntry")+    Int32 ->                                -- n_targets : TBasicType TInt32+    IO ()+++targetTableFree ::+    (MonadIO m) =>+    [TargetEntry] ->                        -- targets+    m ()+targetTableFree targets = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packBlockArray 16 targets'+    gtk_target_table_free targets'' n_targets+    mapM_ touchManagedPtr targets+    freeMem targets''+    return ()+++-- function gtk_stock_set_translate_func+-- Args : [Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TranslateFunc", 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 = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TranslateFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_stock_set_translate_func" gtk_stock_set_translate_func :: +    CString ->                              -- domain : TBasicType TUTF8+    FunPtr TranslateFuncC ->                -- func : TInterface "Gtk" "TranslateFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()++{-# DEPRECATED stockSetTranslateFunc ["(Since version 3.10)"]#-}+stockSetTranslateFunc ::+    (MonadIO m) =>+    T.Text ->                               -- domain+    TranslateFunc ->                        -- func+    m ()+stockSetTranslateFunc domain func = liftIO $ do+    domain' <- textToCString domain+    func' <- mkTranslateFunc (translateFuncWrapper Nothing func)+    let data_ = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    gtk_stock_set_translate_func domain' func' data_ notify+    freeMem domain'+    return ()+++-- function gtk_stock_lookup+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item", argType = TInterface "Gtk" "StockItem", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_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 "gtk_stock_lookup" gtk_stock_lookup :: +    CString ->                              -- stock_id : TBasicType TUTF8+    Ptr StockItem ->                        -- item : TInterface "Gtk" "StockItem"+    IO CInt++{-# DEPRECATED stockLookup ["(Since version 3.10)"]#-}+stockLookup ::+    (MonadIO m) =>+    T.Text ->                               -- stock_id+    m (Bool,StockItem)+stockLookup stock_id = liftIO $ do+    stock_id' <- textToCString stock_id+    item <- callocBytes 32 :: IO (Ptr StockItem)+    result <- gtk_stock_lookup stock_id' item+    let result' = (/= 0) result+    item' <- (wrapPtr StockItem) item+    freeMem stock_id'+    return (result', item')+++-- function gtk_stock_list_ids+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TGSList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_stock_list_ids" gtk_stock_list_ids :: +    IO (Ptr (GSList CString))++{-# DEPRECATED stockListIds ["(Since version 3.10)"]#-}+stockListIds ::+    (MonadIO m) =>+    m [T.Text]+stockListIds  = liftIO $ do+    result <- gtk_stock_list_ids+    checkUnexpectedReturnNULL "gtk_stock_list_ids" result+    result' <- unpackGSList result+    result'' <- mapM cstringToText result'+    mapGSList freeMem result+    g_slist_free result+    return result''+++-- function gtk_stock_add_static+-- Args : [Arg {argName = "items", argType = TCArray False (-1) 1 (TInterface "Gtk" "StockItem"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_items", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_items", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "items", argType = TCArray False (-1) 1 (TInterface "Gtk" "StockItem"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_stock_add_static" gtk_stock_add_static :: +    Ptr StockItem ->                        -- items : TCArray False (-1) 1 (TInterface "Gtk" "StockItem")+    Word32 ->                               -- n_items : TBasicType TUInt32+    IO ()++{-# DEPRECATED stockAddStatic ["(Since version 3.10)"]#-}+stockAddStatic ::+    (MonadIO m) =>+    [StockItem] ->                          -- items+    m ()+stockAddStatic items = liftIO $ do+    let n_items = fromIntegral $ length items+    let items' = map unsafeManagedPtrGetPtr items+    items'' <- packBlockArray 32 items'+    gtk_stock_add_static items'' n_items+    mapM_ touchManagedPtr items+    freeMem items''+    return ()+++-- function gtk_stock_add+-- Args : [Arg {argName = "items", argType = TCArray False (-1) 1 (TInterface "Gtk" "StockItem"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_items", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_items", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "items", argType = TCArray False (-1) 1 (TInterface "Gtk" "StockItem"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_stock_add" gtk_stock_add :: +    Ptr StockItem ->                        -- items : TCArray False (-1) 1 (TInterface "Gtk" "StockItem")+    Word32 ->                               -- n_items : TBasicType TUInt32+    IO ()++{-# DEPRECATED stockAdd ["(Since version 3.10)"]#-}+stockAdd ::+    (MonadIO m) =>+    [StockItem] ->                          -- items+    m ()+stockAdd items = liftIO $ do+    let n_items = fromIntegral $ length items+    let items' = map unsafeManagedPtrGetPtr items+    items'' <- packBlockArray 32 items'+    gtk_stock_add items'' n_items+    mapM_ touchManagedPtr items+    freeMem items''+    return ()+++-- function gtk_show_uri+-- Args : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, 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 = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, 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 = "timestamp", 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 "gtk_show_uri" gtk_show_uri :: +    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    CString ->                              -- uri : TBasicType TUTF8+    Word32 ->                               -- timestamp : TBasicType TUInt32+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++showUri ::+    (MonadIO m, Gdk.ScreenK a) =>+    Maybe (a) ->                            -- screen+    T.Text ->                               -- uri+    Word32 ->                               -- timestamp+    m ()+showUri screen uri timestamp = liftIO $ do+    maybeScreen <- case screen of+        Nothing -> return nullPtr+        Just jScreen -> do+            let jScreen' = unsafeManagedPtrCastPtr jScreen+            return jScreen'+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gtk_show_uri maybeScreen uri' timestamp+        whenJust screen touchManagedPtr+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )+++-- function gtk_set_debug_flags+-- Args : [Arg {argName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "flags", 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 "gtk_set_debug_flags" gtk_set_debug_flags :: +    Word32 ->                               -- flags : TBasicType TUInt32+    IO ()+++setDebugFlags ::+    (MonadIO m) =>+    Word32 ->                               -- flags+    m ()+setDebugFlags flags = liftIO $ do+    gtk_set_debug_flags flags+    return ()+++-- function gtk_selection_remove_all+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_selection_remove_all" gtk_selection_remove_all :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++selectionRemoveAll ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m ()+selectionRemoveAll widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_selection_remove_all widget'+    touchManagedPtr widget+    return ()+++-- function gtk_selection_owner_set_for_display+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", 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 "gtk_selection_owner_set_for_display" gtk_selection_owner_set_for_display :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    Word32 ->                               -- time_ : TBasicType TUInt32+    IO CInt+++selectionOwnerSetForDisplay ::+    (MonadIO m, Gdk.DisplayK a, WidgetK b) =>+    a ->                                    -- display+    Maybe (b) ->                            -- widget+    Gdk.Atom ->                             -- selection+    Word32 ->                               -- time_+    m Bool+selectionOwnerSetForDisplay display widget selection time_ = liftIO $ do+    let display' = unsafeManagedPtrCastPtr display+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    let selection' = unsafeManagedPtrGetPtr selection+    result <- gtk_selection_owner_set_for_display display' maybeWidget selection' time_+    let result' = (/= 0) result+    touchManagedPtr display+    whenJust widget touchManagedPtr+    touchManagedPtr selection+    return result'+++-- function gtk_selection_owner_set+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", 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 "gtk_selection_owner_set" gtk_selection_owner_set :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    Word32 ->                               -- time_ : TBasicType TUInt32+    IO CInt+++selectionOwnerSet ::+    (MonadIO m, WidgetK a) =>+    Maybe (a) ->                            -- widget+    Gdk.Atom ->                             -- selection+    Word32 ->                               -- time_+    m Bool+selectionOwnerSet widget selection time_ = liftIO $ do+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    let selection' = unsafeManagedPtrGetPtr selection+    result <- gtk_selection_owner_set maybeWidget selection' time_+    let result' = (/= 0) result+    whenJust widget touchManagedPtr+    touchManagedPtr selection+    return result'+++-- function gtk_selection_convert+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", 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 "gtk_selection_convert" gtk_selection_convert :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    Ptr Gdk.Atom ->                         -- target : TInterface "Gdk" "Atom"+    Word32 ->                               -- time_ : TBasicType TUInt32+    IO CInt+++selectionConvert ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Gdk.Atom ->                             -- selection+    Gdk.Atom ->                             -- target+    Word32 ->                               -- time_+    m Bool+selectionConvert widget selection target time_ = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let selection' = unsafeManagedPtrGetPtr selection+    let target' = unsafeManagedPtrGetPtr target+    result <- gtk_selection_convert widget' selection' target' time_+    let result' = (/= 0) result+    touchManagedPtr widget+    touchManagedPtr selection+    touchManagedPtr target+    return result'+++-- function gtk_selection_clear_targets+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_selection_clear_targets" gtk_selection_clear_targets :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    IO ()+++selectionClearTargets ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Gdk.Atom ->                             -- selection+    m ()+selectionClearTargets widget selection = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let selection' = unsafeManagedPtrGetPtr selection+    gtk_selection_clear_targets widget' selection'+    touchManagedPtr widget+    touchManagedPtr selection+    return ()+++-- function gtk_selection_add_targets+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ntargets", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "ntargets", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_selection_add_targets" gtk_selection_add_targets :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    Ptr TargetEntry ->                      -- targets : TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry")+    Word32 ->                               -- ntargets : TBasicType TUInt32+    IO ()+++selectionAddTargets ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Gdk.Atom ->                             -- selection+    [TargetEntry] ->                        -- targets+    m ()+selectionAddTargets widget selection targets = liftIO $ do+    let ntargets = fromIntegral $ length targets+    let widget' = unsafeManagedPtrCastPtr widget+    let selection' = unsafeManagedPtrGetPtr selection+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packBlockArray 16 targets'+    gtk_selection_add_targets widget' selection' targets'' ntargets+    touchManagedPtr widget+    touchManagedPtr selection+    mapM_ touchManagedPtr targets+    freeMem targets''+    return ()+++-- function gtk_selection_add_target+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "info", 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 "gtk_selection_add_target" gtk_selection_add_target :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    Ptr Gdk.Atom ->                         -- target : TInterface "Gdk" "Atom"+    Word32 ->                               -- info : TBasicType TUInt32+    IO ()+++selectionAddTarget ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Gdk.Atom ->                             -- selection+    Gdk.Atom ->                             -- target+    Word32 ->                               -- info+    m ()+selectionAddTarget widget selection target info = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let selection' = unsafeManagedPtrGetPtr selection+    let target' = unsafeManagedPtrGetPtr target+    gtk_selection_add_target widget' selection' target' info+    touchManagedPtr widget+    touchManagedPtr selection+    touchManagedPtr target+    return ()+++-- function gtk_rgb_to_hsv+-- Args : [Arg {argName = "r", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "g", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "b", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "r", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "g", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "b", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rgb_to_hsv" gtk_rgb_to_hsv :: +    CDouble ->                              -- r : TBasicType TDouble+    CDouble ->                              -- g : TBasicType TDouble+    CDouble ->                              -- b : TBasicType TDouble+    Ptr CDouble ->                          -- h : TBasicType TDouble+    Ptr CDouble ->                          -- s : TBasicType TDouble+    Ptr CDouble ->                          -- v : TBasicType TDouble+    IO ()+++rgbToHsv ::+    (MonadIO m) =>+    Double ->                               -- r+    Double ->                               -- g+    Double ->                               -- b+    m (Double,Double,Double)+rgbToHsv r g b = liftIO $ do+    let r' = realToFrac r+    let g' = realToFrac g+    let b' = realToFrac b+    h <- allocMem :: IO (Ptr CDouble)+    s <- allocMem :: IO (Ptr CDouble)+    v <- allocMem :: IO (Ptr CDouble)+    gtk_rgb_to_hsv r' g' b' h s v+    h' <- peek h+    let h'' = realToFrac h'+    s' <- peek s+    let s'' = realToFrac s'+    v' <- peek v+    let v'' = realToFrac v'+    freeMem h+    freeMem s+    freeMem v+    return (h'', s'', v'')+++-- function gtk_render_slider+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_slider" gtk_render_slider :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()+++renderSlider ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    Orientation ->                          -- orientation+    m ()+renderSlider context cr x y width height orientation = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_render_slider context' cr' x' y' width' height' orientation'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_option+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_option" gtk_render_option :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderOption ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderOption context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_option context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_line+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x0", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y0", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x1", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y1", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x0", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y0", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x1", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y1", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_line" gtk_render_line :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x0 : TBasicType TDouble+    CDouble ->                              -- y0 : TBasicType TDouble+    CDouble ->                              -- x1 : TBasicType TDouble+    CDouble ->                              -- y1 : TBasicType TDouble+    IO ()+++renderLine ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x0+    Double ->                               -- y0+    Double ->                               -- x1+    Double ->                               -- y1+    m ()+renderLine context cr x0 y0 x1 y1 = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x0' = realToFrac x0+    let y0' = realToFrac y0+    let x1' = realToFrac x1+    let y1' = realToFrac y1+    gtk_render_line context' cr' x0' y0' x1' y1'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_layout+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_layout" gtk_render_layout :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    Ptr Pango.Layout ->                     -- layout : TInterface "Pango" "Layout"+    IO ()+++renderLayout ::+    (MonadIO m, StyleContextK a, Pango.LayoutK b) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    b ->                                    -- layout+    m ()+renderLayout context cr x y layout = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let layout' = unsafeManagedPtrCastPtr layout+    gtk_render_layout context' cr' x' y' layout'+    touchManagedPtr context+    touchManagedPtr cr+    touchManagedPtr layout+    return ()+++-- function gtk_render_insertion_cursor+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", 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},Arg {argName = "direction", argType = TInterface "Pango" "Direction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", 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},Arg {argName = "direction", argType = TInterface "Pango" "Direction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_insertion_cursor" gtk_render_insertion_cursor :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    Ptr Pango.Layout ->                     -- layout : TInterface "Pango" "Layout"+    Int32 ->                                -- index : TBasicType TInt32+    CUInt ->                                -- direction : TInterface "Pango" "Direction"+    IO ()+++renderInsertionCursor ::+    (MonadIO m, StyleContextK a, Pango.LayoutK b) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    b ->                                    -- layout+    Int32 ->                                -- index+    Pango.Direction ->                      -- direction+    m ()+renderInsertionCursor context cr x y layout index direction = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let layout' = unsafeManagedPtrCastPtr layout+    let direction' = (fromIntegral . fromEnum) direction+    gtk_render_insertion_cursor context' cr' x' y' layout' index direction'+    touchManagedPtr context+    touchManagedPtr cr+    touchManagedPtr layout+    return ()+++-- function gtk_render_icon_surface+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_icon_surface" gtk_render_icon_surface :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Cairo.Surface ->                    -- surface : TInterface "cairo" "Surface"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    IO ()+++renderIconSurface ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Cairo.Surface ->                        -- surface+    Double ->                               -- x+    Double ->                               -- y+    m ()+renderIconSurface context cr surface x y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let surface' = unsafeManagedPtrGetPtr surface+    let x' = realToFrac x+    let y' = realToFrac y+    gtk_render_icon_surface context' cr' surface' x' y'+    touchManagedPtr context+    touchManagedPtr cr+    touchManagedPtr surface+    return ()+++-- function gtk_render_icon_pixbuf+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gtk" "IconSource", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "source", argType = TInterface "Gtk" "IconSource", 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}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_icon_pixbuf" gtk_render_icon_pixbuf :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr IconSource ->                       -- source : TInterface "Gtk" "IconSource"+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr GdkPixbuf.Pixbuf)++{-# DEPRECATED renderIconPixbuf ["(Since version 3.10)","Use gtk_icon_theme_load_icon() instead."]#-}+renderIconPixbuf ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    IconSource ->                           -- source+    Int32 ->                                -- size+    m GdkPixbuf.Pixbuf+renderIconPixbuf context source size = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let source' = unsafeManagedPtrGetPtr source+    result <- gtk_render_icon_pixbuf context' source' size+    checkUnexpectedReturnNULL "gtk_render_icon_pixbuf" result+    result' <- (wrapObject GdkPixbuf.Pixbuf) result+    touchManagedPtr context+    touchManagedPtr source+    return result'+++-- function gtk_render_icon+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_icon" gtk_render_icon :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    IO ()+++renderIcon ::+    (MonadIO m, StyleContextK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    b ->                                    -- pixbuf+    Double ->                               -- x+    Double ->                               -- y+    m ()+renderIcon context cr pixbuf x y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    let x' = realToFrac x+    let y' = realToFrac y+    gtk_render_icon context' cr' pixbuf' x' y'+    touchManagedPtr context+    touchManagedPtr cr+    touchManagedPtr pixbuf+    return ()+++-- function gtk_render_handle+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_handle" gtk_render_handle :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderHandle ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderHandle context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_handle context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_frame_gap+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xy0_gap", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xy1_gap", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xy0_gap", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xy1_gap", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_frame_gap" gtk_render_frame_gap :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    CUInt ->                                -- gap_side : TInterface "Gtk" "PositionType"+    CDouble ->                              -- xy0_gap : TBasicType TDouble+    CDouble ->                              -- xy1_gap : TBasicType TDouble+    IO ()+++renderFrameGap ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    PositionType ->                         -- gap_side+    Double ->                               -- xy0_gap+    Double ->                               -- xy1_gap+    m ()+renderFrameGap context cr x y width height gap_side xy0_gap xy1_gap = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    let gap_side' = (fromIntegral . fromEnum) gap_side+    let xy0_gap' = realToFrac xy0_gap+    let xy1_gap' = realToFrac xy1_gap+    gtk_render_frame_gap context' cr' x' y' width' height' gap_side' xy0_gap' xy1_gap'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_frame+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_frame" gtk_render_frame :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderFrame ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderFrame context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_frame context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_focus+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_focus" gtk_render_focus :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderFocus ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderFocus context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_focus context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_extension+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_extension" gtk_render_extension :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    CUInt ->                                -- gap_side : TInterface "Gtk" "PositionType"+    IO ()+++renderExtension ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    PositionType ->                         -- gap_side+    m ()+renderExtension context cr x y width height gap_side = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    let gap_side' = (fromIntegral . fromEnum) gap_side+    gtk_render_extension context' cr' x' y' width' height' gap_side'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_expander+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_expander" gtk_render_expander :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderExpander ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderExpander context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_expander context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_check+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_check" gtk_render_check :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderCheck ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderCheck context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_check context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_background+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_background" gtk_render_background :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderBackground ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderBackground context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_background context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_arrow+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "angle", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "angle", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_arrow" gtk_render_arrow :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- angle : TBasicType TDouble+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- size : TBasicType TDouble+    IO ()+++renderArrow ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- angle+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- size+    m ()+renderArrow context cr angle x y size = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let angle' = realToFrac angle+    let x' = realToFrac x+    let y' = realToFrac y+    let size' = realToFrac size+    gtk_render_arrow context' cr' angle' x' y' size'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_render_activity+-- Args : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_render_activity" gtk_render_activity :: +    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- x : TBasicType TDouble+    CDouble ->                              -- y : TBasicType TDouble+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++renderActivity ::+    (MonadIO m, StyleContextK a) =>+    a ->                                    -- context+    Cairo.Context ->                        -- cr+    Double ->                               -- x+    Double ->                               -- y+    Double ->                               -- width+    Double ->                               -- height+    m ()+renderActivity context cr x y width height = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let cr' = unsafeManagedPtrGetPtr cr+    let x' = realToFrac x+    let y' = realToFrac y+    let width' = realToFrac width+    let height' = realToFrac height+    gtk_render_activity context' cr' x' y' width' height'+    touchManagedPtr context+    touchManagedPtr cr+    return ()+++-- function gtk_recent_manager_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_manager_error_quark" gtk_recent_manager_error_quark :: +    IO Word32+++recentManagerErrorQuark ::+    (MonadIO m) =>+    m Word32+recentManagerErrorQuark  = liftIO $ do+    result <- gtk_recent_manager_error_quark+    return result+++-- function gtk_recent_chooser_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_error_quark" gtk_recent_chooser_error_quark :: +    IO Word32+++recentChooserErrorQuark ::+    (MonadIO m) =>+    m Word32+recentChooserErrorQuark  = liftIO $ do+    result <- gtk_recent_chooser_error_quark+    return result+++-- function gtk_rc_set_default_files+-- Args : [Arg {argName = "filenames", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "filenames", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_set_default_files" gtk_rc_set_default_files :: +    Ptr CString ->                          -- filenames : TCArray True (-1) (-1) (TBasicType TFileName)+    IO ()++{-# DEPRECATED rcSetDefaultFiles ["(Since version 3.0)","Use #GtkStyleContext with a custom #GtkStyleProvider instead"]#-}+rcSetDefaultFiles ::+    (MonadIO m) =>+    [[Char]] ->                             -- filenames+    m ()+rcSetDefaultFiles filenames = liftIO $ do+    filenames' <- packZeroTerminatedFileNameArray filenames+    gtk_rc_set_default_files filenames'+    mapZeroTerminatedCArray freeMem filenames'+    freeMem filenames'+    return ()+++-- function gtk_rc_reset_styles+-- Args : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_reset_styles" gtk_rc_reset_styles :: +    Ptr Settings ->                         -- settings : TInterface "Gtk" "Settings"+    IO ()++{-# DEPRECATED rcResetStyles ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcResetStyles ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- settings+    m ()+rcResetStyles settings = liftIO $ do+    let settings' = unsafeManagedPtrCastPtr settings+    gtk_rc_reset_styles settings'+    touchManagedPtr settings+    return ()+++-- function gtk_rc_reparse_all_for_settings+-- Args : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_load", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_load", 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 "gtk_rc_reparse_all_for_settings" gtk_rc_reparse_all_for_settings :: +    Ptr Settings ->                         -- settings : TInterface "Gtk" "Settings"+    CInt ->                                 -- force_load : TBasicType TBoolean+    IO CInt++{-# DEPRECATED rcReparseAllForSettings ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcReparseAllForSettings ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- settings+    Bool ->                                 -- force_load+    m Bool+rcReparseAllForSettings settings force_load = liftIO $ do+    let settings' = unsafeManagedPtrCastPtr settings+    let force_load' = (fromIntegral . fromEnum) force_load+    result <- gtk_rc_reparse_all_for_settings settings' force_load'+    let result' = (/= 0) result+    touchManagedPtr settings+    return result'+++-- function gtk_rc_reparse_all+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_reparse_all" gtk_rc_reparse_all :: +    IO CInt++{-# DEPRECATED rcReparseAll ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcReparseAll ::+    (MonadIO m) =>+    m Bool+rcReparseAll  = liftIO $ do+    result <- gtk_rc_reparse_all+    let result' = (/= 0) result+    return result'+++-- function gtk_rc_property_parse_requisition+-- Args : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_property_parse_requisition" gtk_rc_property_parse_requisition :: +    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GLib.String ->                      -- gstring : TInterface "GLib" "String"+    Ptr GValue ->                           -- property_value : TInterface "GObject" "Value"+    IO CInt+++rcPropertyParseRequisition ::+    (MonadIO m) =>+    GParamSpec ->                           -- pspec+    GLib.String ->                          -- gstring+    GValue ->                               -- property_value+    m Bool+rcPropertyParseRequisition pspec gstring property_value = liftIO $ do+    let pspec' = unsafeManagedPtrGetPtr pspec+    let gstring' = unsafeManagedPtrGetPtr gstring+    let property_value' = unsafeManagedPtrGetPtr property_value+    result <- gtk_rc_property_parse_requisition pspec' gstring' property_value'+    let result' = (/= 0) result+    touchManagedPtr gstring+    touchManagedPtr property_value+    return result'+++-- function gtk_rc_property_parse_flags+-- Args : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_property_parse_flags" gtk_rc_property_parse_flags :: +    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GLib.String ->                      -- gstring : TInterface "GLib" "String"+    Ptr GValue ->                           -- property_value : TInterface "GObject" "Value"+    IO CInt+++rcPropertyParseFlags ::+    (MonadIO m) =>+    GParamSpec ->                           -- pspec+    GLib.String ->                          -- gstring+    GValue ->                               -- property_value+    m Bool+rcPropertyParseFlags pspec gstring property_value = liftIO $ do+    let pspec' = unsafeManagedPtrGetPtr pspec+    let gstring' = unsafeManagedPtrGetPtr gstring+    let property_value' = unsafeManagedPtrGetPtr property_value+    result <- gtk_rc_property_parse_flags pspec' gstring' property_value'+    let result' = (/= 0) result+    touchManagedPtr gstring+    touchManagedPtr property_value+    return result'+++-- function gtk_rc_property_parse_enum+-- Args : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_property_parse_enum" gtk_rc_property_parse_enum :: +    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GLib.String ->                      -- gstring : TInterface "GLib" "String"+    Ptr GValue ->                           -- property_value : TInterface "GObject" "Value"+    IO CInt+++rcPropertyParseEnum ::+    (MonadIO m) =>+    GParamSpec ->                           -- pspec+    GLib.String ->                          -- gstring+    GValue ->                               -- property_value+    m Bool+rcPropertyParseEnum pspec gstring property_value = liftIO $ do+    let pspec' = unsafeManagedPtrGetPtr pspec+    let gstring' = unsafeManagedPtrGetPtr gstring+    let property_value' = unsafeManagedPtrGetPtr property_value+    result <- gtk_rc_property_parse_enum pspec' gstring' property_value'+    let result' = (/= 0) result+    touchManagedPtr gstring+    touchManagedPtr property_value+    return result'+++-- function gtk_rc_property_parse_color+-- Args : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_property_parse_color" gtk_rc_property_parse_color :: +    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GLib.String ->                      -- gstring : TInterface "GLib" "String"+    Ptr GValue ->                           -- property_value : TInterface "GObject" "Value"+    IO CInt+++rcPropertyParseColor ::+    (MonadIO m) =>+    GParamSpec ->                           -- pspec+    GLib.String ->                          -- gstring+    GValue ->                               -- property_value+    m Bool+rcPropertyParseColor pspec gstring property_value = liftIO $ do+    let pspec' = unsafeManagedPtrGetPtr pspec+    let gstring' = unsafeManagedPtrGetPtr gstring+    let property_value' = unsafeManagedPtrGetPtr property_value+    result <- gtk_rc_property_parse_color pspec' gstring' property_value'+    let result' = (/= 0) result+    touchManagedPtr gstring+    touchManagedPtr property_value+    return result'+++-- function gtk_rc_property_parse_border+-- Args : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gstring", argType = TInterface "GLib" "String", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "property_value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_property_parse_border" gtk_rc_property_parse_border :: +    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GLib.String ->                      -- gstring : TInterface "GLib" "String"+    Ptr GValue ->                           -- property_value : TInterface "GObject" "Value"+    IO CInt+++rcPropertyParseBorder ::+    (MonadIO m) =>+    GParamSpec ->                           -- pspec+    GLib.String ->                          -- gstring+    GValue ->                               -- property_value+    m Bool+rcPropertyParseBorder pspec gstring property_value = liftIO $ do+    let pspec' = unsafeManagedPtrGetPtr pspec+    let gstring' = unsafeManagedPtrGetPtr gstring+    let property_value' = unsafeManagedPtrGetPtr property_value+    result <- gtk_rc_property_parse_border pspec' gstring' property_value'+    let result' = (/= 0) result+    touchManagedPtr gstring+    touchManagedPtr property_value+    return result'+++-- function gtk_rc_parse_string+-- Args : [Arg {argName = "rc_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "rc_string", 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 "gtk_rc_parse_string" gtk_rc_parse_string :: +    CString ->                              -- rc_string : TBasicType TUTF8+    IO ()++{-# DEPRECATED rcParseString ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcParseString ::+    (MonadIO m) =>+    T.Text ->                               -- rc_string+    m ()+rcParseString rc_string = liftIO $ do+    rc_string' <- textToCString rc_string+    gtk_rc_parse_string rc_string'+    freeMem rc_string'+    return ()+++-- function gtk_rc_parse_state+-- Args : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "StateType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_parse_state" gtk_rc_parse_state :: +    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    Ptr CUInt ->                            -- state : TInterface "Gtk" "StateType"+    IO Word32++{-# DEPRECATED rcParseState ["(Since version 3.0)","Use #GtkCssProvider instead"]#-}+rcParseState ::+    (MonadIO m) =>+    GLib.Scanner ->                         -- scanner+    m (Word32,StateType)+rcParseState scanner = liftIO $ do+    let scanner' = unsafeManagedPtrGetPtr scanner+    state <- allocMem :: IO (Ptr CUInt)+    result <- gtk_rc_parse_state scanner' state+    state' <- peek state+    let state'' = (toEnum . fromIntegral) state'+    touchManagedPtr scanner+    freeMem state+    return (result, state'')+++-- function gtk_rc_parse_priority+-- Args : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TInterface "Gtk" "PathPriorityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "priority", argType = TInterface "Gtk" "PathPriorityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_parse_priority" gtk_rc_parse_priority :: +    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    CUInt ->                                -- priority : TInterface "Gtk" "PathPriorityType"+    IO Word32++{-# DEPRECATED rcParsePriority ["(Since version 3.0)","Use #GtkCssProvider instead"]#-}+rcParsePriority ::+    (MonadIO m) =>+    GLib.Scanner ->                         -- scanner+    PathPriorityType ->                     -- priority+    m Word32+rcParsePriority scanner priority = liftIO $ do+    let scanner' = unsafeManagedPtrGetPtr scanner+    let priority' = (fromIntegral . fromEnum) priority+    result <- gtk_rc_parse_priority scanner' priority'+    touchManagedPtr scanner+    return result+++-- function gtk_rc_parse_color_full+-- Args : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "RcStyle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "RcStyle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_parse_color_full" gtk_rc_parse_color_full :: +    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    Ptr RcStyle ->                          -- style : TInterface "Gtk" "RcStyle"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO Word32++{-# DEPRECATED rcParseColorFull ["(Since version 3.0)","Use #GtkCssProvider instead"]#-}+rcParseColorFull ::+    (MonadIO m, RcStyleK a) =>+    GLib.Scanner ->                         -- scanner+    Maybe (a) ->                            -- style+    m (Word32,Gdk.Color)+rcParseColorFull scanner style = liftIO $ do+    let scanner' = unsafeManagedPtrGetPtr scanner+    maybeStyle <- case style of+        Nothing -> return nullPtr+        Just jStyle -> do+            let jStyle' = unsafeManagedPtrCastPtr jStyle+            return jStyle'+    color <- callocBoxedBytes 12 :: IO (Ptr Gdk.Color)+    result <- gtk_rc_parse_color_full scanner' maybeStyle color+    color' <- (wrapBoxed Gdk.Color) color+    touchManagedPtr scanner+    whenJust style touchManagedPtr+    return (result, color')+++-- function gtk_rc_parse_color+-- Args : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_parse_color" gtk_rc_parse_color :: +    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO Word32++{-# DEPRECATED rcParseColor ["(Since version 3.0)","Use #GtkCssProvider instead"]#-}+rcParseColor ::+    (MonadIO m) =>+    GLib.Scanner ->                         -- scanner+    m (Word32,Gdk.Color)+rcParseColor scanner = liftIO $ do+    let scanner' = unsafeManagedPtrGetPtr scanner+    color <- callocBoxedBytes 12 :: IO (Ptr Gdk.Color)+    result <- gtk_rc_parse_color scanner' color+    color' <- (wrapBoxed Gdk.Color) color+    touchManagedPtr scanner+    return (result, color')+++-- function gtk_rc_parse+-- 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_parse" gtk_rc_parse :: +    CString ->                              -- filename : TBasicType TUTF8+    IO ()++{-# DEPRECATED rcParse ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcParse ::+    (MonadIO m) =>+    T.Text ->                               -- filename+    m ()+rcParse filename = liftIO $ do+    filename' <- textToCString filename+    gtk_rc_parse filename'+    freeMem filename'+    return ()+++-- function gtk_rc_get_theme_dir+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_theme_dir" gtk_rc_get_theme_dir :: +    IO CString++{-# DEPRECATED rcGetThemeDir ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcGetThemeDir ::+    (MonadIO m) =>+    m T.Text+rcGetThemeDir  = liftIO $ do+    result <- gtk_rc_get_theme_dir+    checkUnexpectedReturnNULL "gtk_rc_get_theme_dir" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gtk_rc_get_style_by_paths+-- Args : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "class_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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 = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "class_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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 : TInterface "Gtk" "Style"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_style_by_paths" gtk_rc_get_style_by_paths :: +    Ptr Settings ->                         -- settings : TInterface "Gtk" "Settings"+    CString ->                              -- widget_path : TBasicType TUTF8+    CString ->                              -- class_path : TBasicType TUTF8+    CGType ->                               -- type : TBasicType TGType+    IO (Ptr Style)++{-# DEPRECATED rcGetStyleByPaths ["(Since version 3.0)","Use #GtkStyleContext instead"]#-}+rcGetStyleByPaths ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- settings+    Maybe (T.Text) ->                       -- widget_path+    Maybe (T.Text) ->                       -- class_path+    GType ->                                -- type+    m Style+rcGetStyleByPaths settings widget_path class_path type_ = liftIO $ do+    let settings' = unsafeManagedPtrCastPtr settings+    maybeWidget_path <- case widget_path of+        Nothing -> return nullPtr+        Just jWidget_path -> do+            jWidget_path' <- textToCString jWidget_path+            return jWidget_path'+    maybeClass_path <- case class_path of+        Nothing -> return nullPtr+        Just jClass_path -> do+            jClass_path' <- textToCString jClass_path+            return jClass_path'+    let type_' = gtypeToCGType type_+    result <- gtk_rc_get_style_by_paths settings' maybeWidget_path maybeClass_path type_'+    checkUnexpectedReturnNULL "gtk_rc_get_style_by_paths" result+    result' <- (newObject Style) result+    touchManagedPtr settings+    freeMem maybeWidget_path+    freeMem maybeClass_path+    return result'+++-- function gtk_rc_get_style+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Style"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_style" gtk_rc_get_style :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr Style)++{-# DEPRECATED rcGetStyle ["(Since version 3.0)","Use #GtkStyleContext instead"]#-}+rcGetStyle ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m Style+rcGetStyle widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_rc_get_style widget'+    checkUnexpectedReturnNULL "gtk_rc_get_style" result+    result' <- (newObject Style) result+    touchManagedPtr widget+    return result'+++-- function gtk_rc_get_module_dir+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_module_dir" gtk_rc_get_module_dir :: +    IO CString++{-# DEPRECATED rcGetModuleDir ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcGetModuleDir ::+    (MonadIO m) =>+    m [Char]+rcGetModuleDir  = liftIO $ do+    result <- gtk_rc_get_module_dir+    checkUnexpectedReturnNULL "gtk_rc_get_module_dir" result+    result' <- cstringToString result+    freeMem result+    return result'+++-- function gtk_rc_get_im_module_path+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_im_module_path" gtk_rc_get_im_module_path :: +    IO CString++{-# DEPRECATED rcGetImModulePath ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcGetImModulePath ::+    (MonadIO m) =>+    m [Char]+rcGetImModulePath  = liftIO $ do+    result <- gtk_rc_get_im_module_path+    checkUnexpectedReturnNULL "gtk_rc_get_im_module_path" result+    result' <- cstringToString result+    freeMem result+    return result'+++-- function gtk_rc_get_im_module_file+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_im_module_file" gtk_rc_get_im_module_file :: +    IO CString++{-# DEPRECATED rcGetImModuleFile ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcGetImModuleFile ::+    (MonadIO m) =>+    m [Char]+rcGetImModuleFile  = liftIO $ do+    result <- gtk_rc_get_im_module_file+    checkUnexpectedReturnNULL "gtk_rc_get_im_module_file" result+    result' <- cstringToString result+    freeMem result+    return result'+++-- function gtk_rc_get_default_files+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TCArray True (-1) (-1) (TBasicType TFileName)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_get_default_files" gtk_rc_get_default_files :: +    IO (Ptr CString)++{-# DEPRECATED rcGetDefaultFiles ["(Since version 3.0)","Use #GtkStyleContext instead"]#-}+rcGetDefaultFiles ::+    (MonadIO m) =>+    m [[Char]]+rcGetDefaultFiles  = liftIO $ do+    result <- gtk_rc_get_default_files+    checkUnexpectedReturnNULL "gtk_rc_get_default_files" result+    result' <- unpackZeroTerminatedFileNameArray result+    return result'+++-- function gtk_rc_find_pixmap_in_path+-- Args : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixmap_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixmap_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_find_pixmap_in_path" gtk_rc_find_pixmap_in_path :: +    Ptr Settings ->                         -- settings : TInterface "Gtk" "Settings"+    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    CString ->                              -- pixmap_file : TBasicType TUTF8+    IO CString++{-# DEPRECATED rcFindPixmapInPath ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcFindPixmapInPath ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- settings+    GLib.Scanner ->                         -- scanner+    T.Text ->                               -- pixmap_file+    m [Char]+rcFindPixmapInPath settings scanner pixmap_file = liftIO $ do+    let settings' = unsafeManagedPtrCastPtr settings+    let scanner' = unsafeManagedPtrGetPtr scanner+    pixmap_file' <- textToCString pixmap_file+    result <- gtk_rc_find_pixmap_in_path settings' scanner' pixmap_file'+    checkUnexpectedReturnNULL "gtk_rc_find_pixmap_in_path" result+    result' <- cstringToString result+    freeMem result+    touchManagedPtr settings+    touchManagedPtr scanner+    freeMem pixmap_file'+    return result'+++-- function gtk_rc_find_module_in_path+-- Args : [Arg {argName = "module_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "module_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_find_module_in_path" gtk_rc_find_module_in_path :: +    CString ->                              -- module_file : TBasicType TUTF8+    IO CString++{-# DEPRECATED rcFindModuleInPath ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcFindModuleInPath ::+    (MonadIO m) =>+    T.Text ->                               -- module_file+    m [Char]+rcFindModuleInPath module_file = liftIO $ do+    module_file' <- textToCString module_file+    result <- gtk_rc_find_module_in_path module_file'+    checkUnexpectedReturnNULL "gtk_rc_find_module_in_path" result+    result' <- cstringToString result+    freeMem result+    freeMem module_file'+    return result'+++-- function gtk_rc_add_default_file+-- 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_add_default_file" gtk_rc_add_default_file :: +    CString ->                              -- filename : TBasicType TFileName+    IO ()++{-# DEPRECATED rcAddDefaultFile ["(Since version 3.0)","Use #GtkStyleContext with a custom #GtkStyleProvider instead"]#-}+rcAddDefaultFile ::+    (MonadIO m) =>+    [Char] ->                               -- filename+    m ()+rcAddDefaultFile filename = liftIO $ do+    filename' <- stringToCString filename+    gtk_rc_add_default_file filename'+    freeMem filename'+    return ()+++-- function gtk_propagate_event+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_propagate_event" gtk_propagate_event :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    IO ()+++propagateEvent ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Gdk.Event ->                            -- event+    m ()+propagateEvent widget event = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let event' = unsafeManagedPtrGetPtr event+    gtk_propagate_event widget' event'+    touchManagedPtr widget+    touchManagedPtr event+    return ()+++-- function gtk_print_run_page_setup_dialog_async+-- Args : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "done_cb", argType = TInterface "Gtk" "PageSetupDoneFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 4, 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 = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "done_cb", argType = TInterface "Gtk" "PageSetupDoneFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_run_page_setup_dialog_async" gtk_print_run_page_setup_dialog_async :: +    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    Ptr PageSetup ->                        -- page_setup : TInterface "Gtk" "PageSetup"+    Ptr PrintSettings ->                    -- settings : TInterface "Gtk" "PrintSettings"+    FunPtr PageSetupDoneFuncC ->            -- done_cb : TInterface "Gtk" "PageSetupDoneFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++printRunPageSetupDialogAsync ::+    (MonadIO m, WindowK a, PageSetupK b, PrintSettingsK c) =>+    Maybe (a) ->                            -- parent+    Maybe (b) ->                            -- page_setup+    c ->                                    -- settings+    PageSetupDoneFunc ->                    -- done_cb+    m ()+printRunPageSetupDialogAsync parent page_setup settings done_cb = liftIO $ do+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    maybePage_setup <- case page_setup of+        Nothing -> return nullPtr+        Just jPage_setup -> do+            let jPage_setup' = unsafeManagedPtrCastPtr jPage_setup+            return jPage_setup'+    let settings' = unsafeManagedPtrCastPtr settings+    ptrdone_cb <- callocMem :: IO (Ptr (FunPtr PageSetupDoneFuncC))+    done_cb' <- mkPageSetupDoneFunc (pageSetupDoneFuncWrapper (Just ptrdone_cb) done_cb)+    poke ptrdone_cb done_cb'+    let data_ = nullPtr+    gtk_print_run_page_setup_dialog_async maybeParent maybePage_setup settings' done_cb' data_+    whenJust parent touchManagedPtr+    whenJust page_setup touchManagedPtr+    touchManagedPtr settings+    return ()+++-- function gtk_print_run_page_setup_dialog+-- Args : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_run_page_setup_dialog" gtk_print_run_page_setup_dialog :: +    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    Ptr PageSetup ->                        -- page_setup : TInterface "Gtk" "PageSetup"+    Ptr PrintSettings ->                    -- settings : TInterface "Gtk" "PrintSettings"+    IO (Ptr PageSetup)+++printRunPageSetupDialog ::+    (MonadIO m, WindowK a, PageSetupK b, PrintSettingsK c) =>+    Maybe (a) ->                            -- parent+    Maybe (b) ->                            -- page_setup+    c ->                                    -- settings+    m PageSetup+printRunPageSetupDialog parent page_setup settings = liftIO $ do+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    maybePage_setup <- case page_setup of+        Nothing -> return nullPtr+        Just jPage_setup -> do+            let jPage_setup' = unsafeManagedPtrCastPtr jPage_setup+            return jPage_setup'+    let settings' = unsafeManagedPtrCastPtr settings+    result <- gtk_print_run_page_setup_dialog maybeParent maybePage_setup settings'+    checkUnexpectedReturnNULL "gtk_print_run_page_setup_dialog" result+    result' <- (wrapObject PageSetup) result+    whenJust parent touchManagedPtr+    whenJust page_setup touchManagedPtr+    touchManagedPtr settings+    return result'+++-- function gtk_print_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_error_quark" gtk_print_error_quark :: +    IO Word32+++printErrorQuark ::+    (MonadIO m) =>+    m Word32+printErrorQuark  = liftIO $ do+    result <- gtk_print_error_quark+    return result+++-- function gtk_parse_args+-- Args : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_parse_args" gtk_parse_args :: +    Ptr Int32 ->                            -- argc : TBasicType TInt32+    Ptr (Ptr CString) ->                    -- argv : TCArray False (-1) 0 (TBasicType TUTF8)+    IO CInt+++parseArgs ::+    (MonadIO m) =>+    [T.Text] ->                             -- argv+    m (Bool,[T.Text])+parseArgs argv = liftIO $ do+    let argc = fromIntegral $ length argv+    argc' <- allocMem :: IO (Ptr Int32)+    poke argc' argc+    argv' <- packUTF8CArray argv+    argv'' <- allocMem :: IO (Ptr (Ptr CString))+    poke argv'' argv'+    result <- gtk_parse_args argc' argv''+    argc'' <- peek argc'+    let result' = (/= 0) result+    argv''' <- peek argv''+    argv'''' <- (unpackUTF8CArrayWithLength argc'') argv'''+    (mapCArrayWithLength argc'') freeMem argv'''+    freeMem argv'''+    freeMem argc'+    freeMem argv''+    return (result', argv'''')+++-- function gtk_paper_size_get_paper_sizes+-- Args : [Arg {argName = "include_custom", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "include_custom", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "PaperSize")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paper_size_get_paper_sizes" gtk_paper_size_get_paper_sizes :: +    CInt ->                                 -- include_custom : TBasicType TBoolean+    IO (Ptr (GList (Ptr PaperSize)))+++paperSizeGetPaperSizes ::+    (MonadIO m) =>+    Bool ->                                 -- include_custom+    m [PaperSize]+paperSizeGetPaperSizes include_custom = liftIO $ do+    let include_custom' = (fromIntegral . fromEnum) include_custom+    result <- gtk_paper_size_get_paper_sizes include_custom'+    checkUnexpectedReturnNULL "gtk_paper_size_get_paper_sizes" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed PaperSize) result'+    g_list_free result+    return result''+++-- function gtk_paper_size_get_default+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paper_size_get_default" gtk_paper_size_get_default :: +    IO CString+++paperSizeGetDefault ::+    (MonadIO m) =>+    m T.Text+paperSizeGetDefault  = liftIO $ do+    result <- gtk_paper_size_get_default+    checkUnexpectedReturnNULL "gtk_paper_size_get_default" result+    result' <- cstringToText result+    return result'+++-- function gtk_paint_vline+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y1_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y2_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y1_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y2_", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", 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 "gtk_paint_vline" gtk_paint_vline :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- y1_ : TBasicType TInt32+    Int32 ->                                -- y2_ : TBasicType TInt32+    Int32 ->                                -- x : TBasicType TInt32+    IO ()++{-# DEPRECATED paintVline ["(Since version 3.0)","Use gtk_render_line() instead"]#-}+paintVline ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- y1_+    Int32 ->                                -- y2_+    Int32 ->                                -- x+    m ()+paintVline style cr state_type widget detail y1_ y2_ x = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_vline style' cr' state_type' maybeWidget maybeDetail y1_ y2_ x+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_tab+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_tab" gtk_paint_tab :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintTab ["(Since version 3.0)","Use cairo instead"]#-}+paintTab ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintTab style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_tab style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_spinner+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_spinner" gtk_paint_spinner :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Word32 ->                               -- step : TBasicType TUInt32+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintSpinner ["(Since version 3.0)","Use gtk_render_activity() instead"]#-}+paintSpinner ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Word32 ->                               -- step+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintSpinner style cr state_type widget detail step x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_spinner style' cr' state_type' maybeWidget maybeDetail step x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_slider+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paint_slider" gtk_paint_slider :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()++{-# DEPRECATED paintSlider ["(Since version 3.0)","Use gtk_render_slider() instead"]#-}+paintSlider ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    Orientation ->                          -- orientation+    m ()+paintSlider style cr state_type shadow_type widget detail x y width height orientation = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_paint_slider style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height orientation'+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_shadow_gap+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_width", 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 "gtk_paint_shadow_gap" gtk_paint_shadow_gap :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- gap_side : TInterface "Gtk" "PositionType"+    Int32 ->                                -- gap_x : TBasicType TInt32+    Int32 ->                                -- gap_width : TBasicType TInt32+    IO ()++{-# DEPRECATED paintShadowGap ["(Since version 3.0)","Use gtk_render_frame_gap() instead"]#-}+paintShadowGap ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    PositionType ->                         -- gap_side+    Int32 ->                                -- gap_x+    Int32 ->                                -- gap_width+    m ()+paintShadowGap style cr state_type shadow_type widget detail x y width height gap_side gap_x gap_width = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let gap_side' = (fromIntegral . fromEnum) gap_side+    gtk_paint_shadow_gap style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height gap_side' gap_x gap_width+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_shadow+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_shadow" gtk_paint_shadow :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintShadow ["(Since version 3.0)","Use gtk_render_frame() instead"]#-}+paintShadow ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintShadow style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_shadow style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_resize_grip+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edge", argType = TInterface "Gdk" "WindowEdge", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edge", argType = TInterface "Gdk" "WindowEdge", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_resize_grip" gtk_paint_resize_grip :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    CUInt ->                                -- edge : TInterface "Gdk" "WindowEdge"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintResizeGrip ["(Since version 3.0)","Use gtk_render_handle() instead"]#-}+paintResizeGrip ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Gdk.WindowEdge ->                       -- edge+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintResizeGrip style cr state_type widget detail edge x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let edge' = (fromIntegral . fromEnum) edge+    gtk_paint_resize_grip style' cr' state_type' maybeWidget maybeDetail edge' x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_option+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_option" gtk_paint_option :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintOption ["(Since version 3.0)","Use gtk_render_option() instead"]#-}+paintOption ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintOption style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_option style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_layout+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_text", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_text", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TInterface "Pango" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paint_layout" gtk_paint_layout :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CInt ->                                 -- use_text : TBasicType TBoolean+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Ptr Pango.Layout ->                     -- layout : TInterface "Pango" "Layout"+    IO ()++{-# DEPRECATED paintLayout ["(Since version 3.0)","Use gtk_render_layout() instead"]#-}+paintLayout ::+    (MonadIO m, StyleK a, WidgetK b, Pango.LayoutK c) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Bool ->                                 -- use_text+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    c ->                                    -- layout+    m ()+paintLayout style cr state_type use_text widget detail x y layout = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let use_text' = (fromIntegral . fromEnum) use_text+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let layout' = unsafeManagedPtrCastPtr layout+    gtk_paint_layout style' cr' state_type' use_text' maybeWidget maybeDetail x y layout'+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    touchManagedPtr layout+    freeMem maybeDetail+    return ()+++-- function gtk_paint_hline+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x1", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x2", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x1", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x2", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_paint_hline" gtk_paint_hline :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x1 : TBasicType TInt32+    Int32 ->                                -- x2 : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO ()++{-# DEPRECATED paintHline ["(Since version 3.0)","Use gtk_render_line() instead"]#-}+paintHline ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x1+    Int32 ->                                -- x2+    Int32 ->                                -- y+    m ()+paintHline style cr state_type widget detail x1 x2 y = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_hline style' cr' state_type' maybeWidget maybeDetail x1 x2 y+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_handle+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paint_handle" gtk_paint_handle :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()++{-# DEPRECATED paintHandle ["(Since version 3.0)","Use gtk_render_handle() instead"]#-}+paintHandle ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    Orientation ->                          -- orientation+    m ()+paintHandle style cr state_type shadow_type widget detail x y width height orientation = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_paint_handle style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height orientation'+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_focus+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_focus" gtk_paint_focus :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintFocus ["(Since version 3.0)","Use gtk_render_focus() instead"]#-}+paintFocus ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintFocus style cr state_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_focus style' cr' state_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_flat_box+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_flat_box" gtk_paint_flat_box :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintFlatBox ["(Since version 3.0)","Use gtk_render_frame() and gtk_render_background() instead"]#-}+paintFlatBox ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintFlatBox style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_flat_box style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_extension+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paint_extension" gtk_paint_extension :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- gap_side : TInterface "Gtk" "PositionType"+    IO ()++{-# DEPRECATED paintExtension ["(Since version 3.0)","Use gtk_render_extension() instead"]#-}+paintExtension ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    PositionType ->                         -- gap_side+    m ()+paintExtension style cr state_type shadow_type widget detail x y width height gap_side = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let gap_side' = (fromIntegral . fromEnum) gap_side+    gtk_paint_extension style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height gap_side'+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_expander+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expander_style", argType = TInterface "Gtk" "ExpanderStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expander_style", argType = TInterface "Gtk" "ExpanderStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paint_expander" gtk_paint_expander :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    CUInt ->                                -- expander_style : TInterface "Gtk" "ExpanderStyle"+    IO ()++{-# DEPRECATED paintExpander ["(Since version 3.0)","Use gtk_render_expander() instead"]#-}+paintExpander ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    ExpanderStyle ->                        -- expander_style+    m ()+paintExpander style cr state_type widget detail x y expander_style = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let expander_style' = (fromIntegral . fromEnum) expander_style+    gtk_paint_expander style' cr' state_type' maybeWidget maybeDetail x y expander_style'+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_diamond+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_diamond" gtk_paint_diamond :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintDiamond ["(Since version 3.0)","Use cairo instead"]#-}+paintDiamond ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintDiamond style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_diamond style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_check+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_check" gtk_paint_check :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintCheck ["(Since version 3.0)","Use gtk_render_check() instead"]#-}+paintCheck ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintCheck style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_check style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_box_gap+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gap_width", 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 "gtk_paint_box_gap" gtk_paint_box_gap :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- gap_side : TInterface "Gtk" "PositionType"+    Int32 ->                                -- gap_x : TBasicType TInt32+    Int32 ->                                -- gap_width : TBasicType TInt32+    IO ()++{-# DEPRECATED paintBoxGap ["(Since version 3.0)","Use gtk_render_frame_gap() instead"]#-}+paintBoxGap ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    PositionType ->                         -- gap_side+    Int32 ->                                -- gap_x+    Int32 ->                                -- gap_width+    m ()+paintBoxGap style cr state_type shadow_type widget detail x y width height gap_side gap_x gap_width = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let gap_side' = (fromIntegral . fromEnum) gap_side+    gtk_paint_box_gap style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height gap_side' gap_x gap_width+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_box+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_box" gtk_paint_box :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintBox ["(Since version 3.0)","Use gtk_render_frame() and gtk_render_background() instead"]#-}+paintBox ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintBox style cr state_type shadow_type widget detail x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    gtk_paint_box style' cr' state_type' shadow_type' maybeWidget maybeDetail x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_paint_arrow+-- Args : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state_type", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_paint_arrow" gtk_paint_arrow :: +    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CUInt ->                                -- state_type : TInterface "Gtk" "StateType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- detail : TBasicType TUTF8+    CUInt ->                                -- arrow_type : TInterface "Gtk" "ArrowType"+    CInt ->                                 -- fill : TBasicType TBoolean+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED paintArrow ["(Since version 3.0)","Use gtk_render_arrow() instead"]#-}+paintArrow ::+    (MonadIO m, StyleK a, WidgetK b) =>+    a ->                                    -- style+    Cairo.Context ->                        -- cr+    StateType ->                            -- state_type+    ShadowType ->                           -- shadow_type+    Maybe (b) ->                            -- widget+    Maybe (T.Text) ->                       -- detail+    ArrowType ->                            -- arrow_type+    Bool ->                                 -- fill+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+paintArrow style cr state_type shadow_type widget detail arrow_type fill x y width height = liftIO $ do+    let style' = unsafeManagedPtrCastPtr style+    let cr' = unsafeManagedPtrGetPtr cr+    let state_type' = (fromIntegral . fromEnum) state_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    maybeDetail <- case detail of+        Nothing -> return nullPtr+        Just jDetail -> do+            jDetail' <- textToCString jDetail+            return jDetail'+    let arrow_type' = (fromIntegral . fromEnum) arrow_type+    let fill' = (fromIntegral . fromEnum) fill+    gtk_paint_arrow style' cr' state_type' shadow_type' maybeWidget maybeDetail arrow_type' fill' x y width height+    touchManagedPtr style+    touchManagedPtr cr+    whenJust widget touchManagedPtr+    freeMem maybeDetail+    return ()+++-- function gtk_main_quit+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_main_quit" gtk_main_quit :: +    IO ()+++mainQuit ::+    (MonadIO m) =>+    m ()+mainQuit  = liftIO $ do+    gtk_main_quit+    return ()+++-- function gtk_main_level+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_main_level" gtk_main_level :: +    IO Word32+++mainLevel ::+    (MonadIO m) =>+    m Word32+mainLevel  = liftIO $ do+    result <- gtk_main_level+    return result+++-- function gtk_main_iteration_do+-- Args : [Arg {argName = "blocking", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "blocking", 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 "gtk_main_iteration_do" gtk_main_iteration_do :: +    CInt ->                                 -- blocking : TBasicType TBoolean+    IO CInt+++mainIterationDo ::+    (MonadIO m) =>+    Bool ->                                 -- blocking+    m Bool+mainIterationDo blocking = liftIO $ do+    let blocking' = (fromIntegral . fromEnum) blocking+    result <- gtk_main_iteration_do blocking'+    let result' = (/= 0) result+    return result'+++-- function gtk_main_iteration+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_main_iteration" gtk_main_iteration :: +    IO CInt+++mainIteration ::+    (MonadIO m) =>+    m Bool+mainIteration  = liftIO $ do+    result <- gtk_main_iteration+    let result' = (/= 0) result+    return result'+++-- function gtk_main_do_event+-- Args : [Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_main_do_event" gtk_main_do_event :: +    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    IO ()+++mainDoEvent ::+    (MonadIO m) =>+    Gdk.Event ->                            -- event+    m ()+mainDoEvent event = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    gtk_main_do_event event'+    touchManagedPtr event+    return ()+++-- function gtk_main+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_main" gtk_main :: +    IO ()+++main ::+    (MonadIO m) =>+    m ()+main  = liftIO $ do+    gtk_main+    return ()+++-- function gtk_key_snooper_remove+-- Args : [Arg {argName = "snooper_handler_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "snooper_handler_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 "gtk_key_snooper_remove" gtk_key_snooper_remove :: +    Word32 ->                               -- snooper_handler_id : TBasicType TUInt32+    IO ()++{-# DEPRECATED keySnooperRemove ["(Since version 3.4)","Key snooping should not be done. Events should","    be handled by widgets."]#-}+keySnooperRemove ::+    (MonadIO m) =>+    Word32 ->                               -- snooper_handler_id+    m ()+keySnooperRemove snooper_handler_id = liftIO $ do+    gtk_key_snooper_remove snooper_handler_id+    return ()+++-- function gtk_init_with_args+-- Args : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "parameter_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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},Arg {argName = "translation_domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "parameter_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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},Arg {argName = "translation_domain", 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 "gtk_init_with_args" gtk_init_with_args :: +    Ptr Int32 ->                            -- argc : TBasicType TInt32+    Ptr (Ptr CString) ->                    -- argv : TCArray False (-1) 0 (TBasicType TUTF8)+    CString ->                              -- parameter_string : TBasicType TUTF8+    Ptr (Ptr GLib.OptionEntry) ->           -- entries : TCArray True (-1) (-1) (TInterface "GLib" "OptionEntry")+    CString ->                              -- translation_domain : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++initWithArgs ::+    (MonadIO m) =>+    Maybe ([T.Text]) ->                     -- argv+    Maybe (T.Text) ->                       -- parameter_string+    [GLib.OptionEntry] ->                   -- entries+    Maybe (T.Text) ->                       -- translation_domain+    m ((Maybe [T.Text]))+initWithArgs argv parameter_string entries translation_domain = liftIO $ do+    let argc = case argv of+            Nothing -> 0+            Just jArgv -> fromIntegral $ length jArgv+    argc' <- allocMem :: IO (Ptr Int32)+    poke argc' argc+    maybeArgv <- case argv of+        Nothing -> return nullPtr+        Just jArgv -> do+            jArgv' <- packUTF8CArray jArgv+            return jArgv'+    maybeArgv' <- allocMem :: IO (Ptr (Ptr CString))+    poke maybeArgv' maybeArgv+    maybeParameter_string <- case parameter_string of+        Nothing -> return nullPtr+        Just jParameter_string -> do+            jParameter_string' <- textToCString jParameter_string+            return jParameter_string'+    let entries' = map unsafeManagedPtrGetPtr entries+    entries'' <- packZeroTerminatedPtrArray entries'+    maybeTranslation_domain <- case translation_domain of+        Nothing -> return nullPtr+        Just jTranslation_domain -> do+            jTranslation_domain' <- textToCString jTranslation_domain+            return jTranslation_domain'+    onException (do+        _ <- propagateGError $ gtk_init_with_args argc' maybeArgv' maybeParameter_string entries'' maybeTranslation_domain+        argc'' <- peek argc'+        maybeArgv'' <- peek maybeArgv'+        maybeMaybeArgv'' <- convertIfNonNull maybeArgv'' $ \maybeArgv''' -> do+            maybeArgv'''' <- (unpackUTF8CArrayWithLength argc'') maybeArgv'''+            (mapCArrayWithLength argc'') freeMem maybeArgv'''+            freeMem maybeArgv'''+            return maybeArgv''''+        mapM_ touchManagedPtr entries+        freeMem argc'+        freeMem maybeArgv'+        freeMem maybeParameter_string+        freeMem entries''+        freeMem maybeTranslation_domain+        return maybeMaybeArgv''+     ) (do+        freeMem argc'+        freeMem maybeArgv'+        freeMem maybeParameter_string+        freeMem entries''+        freeMem maybeTranslation_domain+     )+++-- function gtk_init_check+-- Args : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_init_check" gtk_init_check :: +    Ptr Int32 ->                            -- argc : TBasicType TInt32+    Ptr (Ptr CString) ->                    -- argv : TCArray False (-1) 0 (TBasicType TUTF8)+    IO CInt+++initCheck ::+    (MonadIO m) =>+    Maybe ([T.Text]) ->                     -- argv+    m (Bool,(Maybe [T.Text]))+initCheck argv = liftIO $ do+    let argc = case argv of+            Nothing -> 0+            Just jArgv -> fromIntegral $ length jArgv+    argc' <- allocMem :: IO (Ptr Int32)+    poke argc' argc+    maybeArgv <- case argv of+        Nothing -> return nullPtr+        Just jArgv -> do+            jArgv' <- packUTF8CArray jArgv+            return jArgv'+    maybeArgv' <- allocMem :: IO (Ptr (Ptr CString))+    poke maybeArgv' maybeArgv+    result <- gtk_init_check argc' maybeArgv'+    argc'' <- peek argc'+    let result' = (/= 0) result+    maybeArgv'' <- peek maybeArgv'+    maybeMaybeArgv'' <- convertIfNonNull maybeArgv'' $ \maybeArgv''' -> do+        maybeArgv'''' <- (unpackUTF8CArrayWithLength argc'') maybeArgv'''+        (mapCArrayWithLength argc'') freeMem maybeArgv'''+        freeMem maybeArgv'''+        return maybeArgv''''+    freeMem argc'+    freeMem maybeArgv'+    return (result', maybeMaybeArgv'')+++-- function gtk_init+-- Args : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "argc", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "argv", argType = TCArray False (-1) 0 (TBasicType TUTF8), direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_init" gtk_init :: +    Ptr Int32 ->                            -- argc : TBasicType TInt32+    Ptr (Ptr CString) ->                    -- argv : TCArray False (-1) 0 (TBasicType TUTF8)+    IO ()+++init ::+    (MonadIO m) =>+    Maybe ([T.Text]) ->                     -- argv+    m ((Maybe [T.Text]))+init argv = liftIO $ do+    let argc = case argv of+            Nothing -> 0+            Just jArgv -> fromIntegral $ length jArgv+    argc' <- allocMem :: IO (Ptr Int32)+    poke argc' argc+    maybeArgv <- case argv of+        Nothing -> return nullPtr+        Just jArgv -> do+            jArgv' <- packUTF8CArray jArgv+            return jArgv'+    maybeArgv' <- allocMem :: IO (Ptr (Ptr CString))+    poke maybeArgv' maybeArgv+    gtk_init argc' maybeArgv'+    argc'' <- peek argc'+    maybeArgv'' <- peek maybeArgv'+    maybeMaybeArgv'' <- convertIfNonNull maybeArgv'' $ \maybeArgv''' -> do+        maybeArgv'''' <- (unpackUTF8CArrayWithLength argc'') maybeArgv'''+        (mapCArrayWithLength argc'') freeMem maybeArgv'''+        freeMem maybeArgv'''+        return maybeArgv''''+    freeMem argc'+    freeMem maybeArgv'+    return maybeMaybeArgv''+++-- function gtk_icon_theme_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_error_quark" gtk_icon_theme_error_quark :: +    IO Word32+++iconThemeErrorQuark ::+    (MonadIO m) =>+    m Word32+iconThemeErrorQuark  = liftIO $ do+    result <- gtk_icon_theme_error_quark+    return result+++-- function gtk_icon_size_register_alias+-- Args : [Arg {argName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "alias", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", 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 "gtk_icon_size_register_alias" gtk_icon_size_register_alias :: +    CString ->                              -- alias : TBasicType TUTF8+    Int32 ->                                -- target : TBasicType TInt32+    IO ()++{-# DEPRECATED iconSizeRegisterAlias ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconSizeRegisterAlias ::+    (MonadIO m) =>+    T.Text ->                               -- alias+    Int32 ->                                -- target+    m ()+iconSizeRegisterAlias alias target = liftIO $ do+    alias' <- textToCString alias+    gtk_icon_size_register_alias alias' target+    freeMem alias'+    return ()+++-- function gtk_icon_size_register+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, 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 = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_size_register" gtk_icon_size_register :: +    CString ->                              -- name : TBasicType TUTF8+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO Int32++{-# DEPRECATED iconSizeRegister ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconSizeRegister ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Int32 ->                                -- width+    Int32 ->                                -- height+    m Int32+iconSizeRegister name width height = liftIO $ do+    name' <- textToCString name+    result <- gtk_icon_size_register name' width height+    freeMem name'+    return result+++-- function gtk_icon_size_lookup_for_settings+-- Args : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", 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 = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "settings", argType = TInterface "Gtk" "Settings", 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}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_size_lookup_for_settings" gtk_icon_size_lookup_for_settings :: +    Ptr Settings ->                         -- settings : TInterface "Gtk" "Settings"+    Int32 ->                                -- size : TBasicType TInt32+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO CInt++{-# DEPRECATED iconSizeLookupForSettings ["(Since version 3.10)","Use gtk_icon_size_lookup() instead."]#-}+iconSizeLookupForSettings ::+    (MonadIO m, SettingsK a) =>+    a ->                                    -- settings+    Int32 ->                                -- size+    m (Bool,Int32,Int32)+iconSizeLookupForSettings settings size = liftIO $ do+    let settings' = unsafeManagedPtrCastPtr settings+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    result <- gtk_icon_size_lookup_for_settings settings' size width height+    let result' = (/= 0) result+    width' <- peek width+    height' <- peek height+    touchManagedPtr settings+    freeMem width+    freeMem height+    return (result', width', height')+++-- function gtk_icon_size_lookup+-- Args : [Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "size", 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 "gtk_icon_size_lookup" gtk_icon_size_lookup :: +    Int32 ->                                -- size : TBasicType TInt32+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO CInt+++iconSizeLookup ::+    (MonadIO m) =>+    Int32 ->                                -- size+    m (Bool,Int32,Int32)+iconSizeLookup size = liftIO $ do+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    result <- gtk_icon_size_lookup size width height+    let result' = (/= 0) result+    width' <- peek width+    height' <- peek height+    freeMem width+    freeMem height+    return (result', width', height')+++-- function gtk_icon_size_get_name+-- Args : [Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_size_get_name" gtk_icon_size_get_name :: +    Int32 ->                                -- size : TBasicType TInt32+    IO CString++{-# DEPRECATED iconSizeGetName ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconSizeGetName ::+    (MonadIO m) =>+    Int32 ->                                -- size+    m T.Text+iconSizeGetName size = liftIO $ do+    result <- gtk_icon_size_get_name size+    checkUnexpectedReturnNULL "gtk_icon_size_get_name" result+    result' <- cstringToText result+    return result'+++-- function gtk_icon_size_from_name+-- 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 : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_size_from_name" gtk_icon_size_from_name :: +    CString ->                              -- name : TBasicType TUTF8+    IO Int32++{-# DEPRECATED iconSizeFromName ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconSizeFromName ::+    (MonadIO m) =>+    T.Text ->                               -- name+    m Int32+iconSizeFromName name = liftIO $ do+    name' <- textToCString name+    result <- gtk_icon_size_from_name name'+    freeMem name'+    return result+++-- function gtk_grab_get_current+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grab_get_current" gtk_grab_get_current :: +    IO (Ptr Widget)+++grabGetCurrent ::+    (MonadIO m) =>+    m Widget+grabGetCurrent  = liftIO $ do+    result <- gtk_grab_get_current+    checkUnexpectedReturnNULL "gtk_grab_get_current" result+    result' <- (newObject Widget) result+    return result'+++-- function gtk_get_option_group+-- Args : [Arg {argName = "open_default_display", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "open_default_display", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "OptionGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_option_group" gtk_get_option_group :: +    CInt ->                                 -- open_default_display : TBasicType TBoolean+    IO (Ptr GLib.OptionGroup)+++getOptionGroup ::+    (MonadIO m) =>+    Bool ->                                 -- open_default_display+    m GLib.OptionGroup+getOptionGroup open_default_display = liftIO $ do+    let open_default_display' = (fromIntegral . fromEnum) open_default_display+    result <- gtk_get_option_group open_default_display'+    checkUnexpectedReturnNULL "gtk_get_option_group" result+    result' <- (wrapBoxed GLib.OptionGroup) result+    return result'+++-- function gtk_get_minor_version+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_minor_version" gtk_get_minor_version :: +    IO Word32+++getMinorVersion ::+    (MonadIO m) =>+    m Word32+getMinorVersion  = liftIO $ do+    result <- gtk_get_minor_version+    return result+++-- function gtk_get_micro_version+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_micro_version" gtk_get_micro_version :: +    IO Word32+++getMicroVersion ::+    (MonadIO m) =>+    m Word32+getMicroVersion  = liftIO $ do+    result <- gtk_get_micro_version+    return result+++-- function gtk_get_major_version+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_major_version" gtk_get_major_version :: +    IO Word32+++getMajorVersion ::+    (MonadIO m) =>+    m Word32+getMajorVersion  = liftIO $ do+    result <- gtk_get_major_version+    return result+++-- function gtk_get_locale_direction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "TextDirection"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_locale_direction" gtk_get_locale_direction :: +    IO CUInt+++getLocaleDirection ::+    (MonadIO m) =>+    m TextDirection+getLocaleDirection  = liftIO $ do+    result <- gtk_get_locale_direction+    let result' = (toEnum . fromIntegral) result+    return result'+++-- function gtk_get_interface_age+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_interface_age" gtk_get_interface_age :: +    IO Word32+++getInterfaceAge ::+    (MonadIO m) =>+    m Word32+getInterfaceAge  = liftIO $ do+    result <- gtk_get_interface_age+    return result+++-- function gtk_get_event_widget+-- Args : [Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_event_widget" gtk_get_event_widget :: +    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    IO (Ptr Widget)+++getEventWidget ::+    (MonadIO m) =>+    Gdk.Event ->                            -- event+    m Widget+getEventWidget event = liftIO $ do+    let event' = unsafeManagedPtrGetPtr event+    result <- gtk_get_event_widget event'+    checkUnexpectedReturnNULL "gtk_get_event_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr event+    return result'+++-- function gtk_get_default_language+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Pango" "Language"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_default_language" gtk_get_default_language :: +    IO (Ptr Pango.Language)+++getDefaultLanguage ::+    (MonadIO m) =>+    m Pango.Language+getDefaultLanguage  = liftIO $ do+    result <- gtk_get_default_language+    checkUnexpectedReturnNULL "gtk_get_default_language" result+    result' <- (newBoxed Pango.Language) result+    return result'+++-- function gtk_get_debug_flags+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_debug_flags" gtk_get_debug_flags :: +    IO Word32+++getDebugFlags ::+    (MonadIO m) =>+    m Word32+getDebugFlags  = liftIO $ do+    result <- gtk_get_debug_flags+    return result+++-- function gtk_get_current_event_time+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_current_event_time" gtk_get_current_event_time :: +    IO Word32+++getCurrentEventTime ::+    (MonadIO m) =>+    m Word32+getCurrentEventTime  = liftIO $ do+    result <- gtk_get_current_event_time+    return result+++-- function gtk_get_current_event_state+-- Args : [Arg {argName = "state", argType = TInterface "Gdk" "ModifierType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_current_event_state" gtk_get_current_event_state :: +    Ptr CUInt ->                            -- state : TInterface "Gdk" "ModifierType"+    IO CInt+++getCurrentEventState ::+    (MonadIO m) =>+    m (Bool,[Gdk.ModifierType])+getCurrentEventState  = liftIO $ do+    state <- allocMem :: IO (Ptr CUInt)+    result <- gtk_get_current_event_state state+    let result' = (/= 0) result+    state' <- peek state+    let state'' = wordToGFlags state'+    freeMem state+    return (result', state'')+++-- function gtk_get_current_event_device+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gdk" "Device"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_current_event_device" gtk_get_current_event_device :: +    IO (Ptr Gdk.Device)+++getCurrentEventDevice ::+    (MonadIO m) =>+    m Gdk.Device+getCurrentEventDevice  = liftIO $ do+    result <- gtk_get_current_event_device+    checkUnexpectedReturnNULL "gtk_get_current_event_device" result+    result' <- (newObject Gdk.Device) result+    return result'+++-- function gtk_get_current_event+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gdk" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_current_event" gtk_get_current_event :: +    IO (Ptr Gdk.Event)+++getCurrentEvent ::+    (MonadIO m) =>+    m Gdk.Event+getCurrentEvent  = liftIO $ do+    result <- gtk_get_current_event+    checkUnexpectedReturnNULL "gtk_get_current_event" result+    result' <- (wrapBoxed Gdk.Event) result+    return result'+++-- function gtk_get_binary_age+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_get_binary_age" gtk_get_binary_age :: +    IO Word32+++getBinaryAge ::+    (MonadIO m) =>+    m Word32+getBinaryAge  = liftIO $ do+    result <- gtk_get_binary_age+    return result+++-- function gtk_file_chooser_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_error_quark" gtk_file_chooser_error_quark :: +    IO Word32+++fileChooserErrorQuark ::+    (MonadIO m) =>+    m Word32+fileChooserErrorQuark  = liftIO $ do+    result <- gtk_file_chooser_error_quark+    return result+++-- function gtk_false+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_false" gtk_false :: +    IO CInt+++false ::+    (MonadIO m) =>+    m Bool+false  = liftIO $ do+    result <- gtk_false+    let result' = (/= 0) result+    return result'+++-- function gtk_events_pending+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_events_pending" gtk_events_pending :: +    IO CInt+++eventsPending ::+    (MonadIO m) =>+    m Bool+eventsPending  = liftIO $ do+    result <- gtk_events_pending+    let result' = (/= 0) result+    return result'+++-- function gtk_draw_insertion_cursor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_primary", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "TextDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_arrow", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_primary", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "TextDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_arrow", 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 "gtk_draw_insertion_cursor" gtk_draw_insertion_cursor :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Gdk.Rectangle ->                    -- location : TInterface "Gdk" "Rectangle"+    CInt ->                                 -- is_primary : TBasicType TBoolean+    CUInt ->                                -- direction : TInterface "Gtk" "TextDirection"+    CInt ->                                 -- draw_arrow : TBasicType TBoolean+    IO ()++{-# DEPRECATED drawInsertionCursor ["(Since version 3.4)","Use gtk_render_insertion_cursor() instead."]#-}+drawInsertionCursor ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Cairo.Context ->                        -- cr+    Gdk.Rectangle ->                        -- location+    Bool ->                                 -- is_primary+    TextDirection ->                        -- direction+    Bool ->                                 -- draw_arrow+    m ()+drawInsertionCursor widget cr location is_primary direction draw_arrow = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let cr' = unsafeManagedPtrGetPtr cr+    let location' = unsafeManagedPtrGetPtr location+    let is_primary' = (fromIntegral . fromEnum) is_primary+    let direction' = (fromIntegral . fromEnum) direction+    let draw_arrow' = (fromIntegral . fromEnum) draw_arrow+    gtk_draw_insertion_cursor widget' cr' location' is_primary' direction' draw_arrow'+    touchManagedPtr widget+    touchManagedPtr cr+    touchManagedPtr location+    return ()+++-- function gtk_drag_set_icon_widget+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", 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 "gtk_drag_set_icon_widget" gtk_drag_set_icon_widget :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- hot_x : TBasicType TInt32+    Int32 ->                                -- hot_y : TBasicType TInt32+    IO ()+++dragSetIconWidget ::+    (MonadIO m, Gdk.DragContextK a, WidgetK b) =>+    a ->                                    -- context+    b ->                                    -- widget+    Int32 ->                                -- hot_x+    Int32 ->                                -- hot_y+    m ()+dragSetIconWidget context widget hot_x hot_y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_drag_set_icon_widget context' widget' hot_x hot_y+    touchManagedPtr context+    touchManagedPtr widget+    return ()+++-- function gtk_drag_set_icon_surface+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_drag_set_icon_surface" gtk_drag_set_icon_surface :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    Ptr Cairo.Surface ->                    -- surface : TInterface "cairo" "Surface"+    IO ()+++dragSetIconSurface ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    Cairo.Surface ->                        -- surface+    m ()+dragSetIconSurface context surface = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let surface' = unsafeManagedPtrGetPtr surface+    gtk_drag_set_icon_surface context' surface'+    touchManagedPtr context+    touchManagedPtr surface+    return ()+++-- function gtk_drag_set_icon_stock+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", 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 "gtk_drag_set_icon_stock" gtk_drag_set_icon_stock :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    CString ->                              -- stock_id : TBasicType TUTF8+    Int32 ->                                -- hot_x : TBasicType TInt32+    Int32 ->                                -- hot_y : TBasicType TInt32+    IO ()++{-# DEPRECATED dragSetIconStock ["(Since version 3.10)","Use gtk_drag_set_icon_name() instead."]#-}+dragSetIconStock ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    T.Text ->                               -- stock_id+    Int32 ->                                -- hot_x+    Int32 ->                                -- hot_y+    m ()+dragSetIconStock context stock_id hot_x hot_y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    stock_id' <- textToCString stock_id+    gtk_drag_set_icon_stock context' stock_id' hot_x hot_y+    touchManagedPtr context+    freeMem stock_id'+    return ()+++-- function gtk_drag_set_icon_pixbuf+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", 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 "gtk_drag_set_icon_pixbuf" gtk_drag_set_icon_pixbuf :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    Int32 ->                                -- hot_x : TBasicType TInt32+    Int32 ->                                -- hot_y : TBasicType TInt32+    IO ()+++dragSetIconPixbuf ::+    (MonadIO m, Gdk.DragContextK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- context+    b ->                                    -- pixbuf+    Int32 ->                                -- hot_x+    Int32 ->                                -- hot_y+    m ()+dragSetIconPixbuf context pixbuf hot_x hot_y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    gtk_drag_set_icon_pixbuf context' pixbuf' hot_x hot_y+    touchManagedPtr context+    touchManagedPtr pixbuf+    return ()+++-- function gtk_drag_set_icon_name+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", 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 "gtk_drag_set_icon_name" gtk_drag_set_icon_name :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- hot_x : TBasicType TInt32+    Int32 ->                                -- hot_y : TBasicType TInt32+    IO ()+++dragSetIconName ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    T.Text ->                               -- icon_name+    Int32 ->                                -- hot_x+    Int32 ->                                -- hot_y+    m ()+dragSetIconName context icon_name hot_x hot_y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    icon_name' <- textToCString icon_name+    gtk_drag_set_icon_name context' icon_name' hot_x hot_y+    touchManagedPtr context+    freeMem icon_name'+    return ()+++-- function gtk_drag_set_icon_gicon+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", 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},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", 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},Arg {argName = "hot_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hot_y", 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 "gtk_drag_set_icon_gicon" gtk_drag_set_icon_gicon :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    Int32 ->                                -- hot_x : TBasicType TInt32+    Int32 ->                                -- hot_y : TBasicType TInt32+    IO ()+++dragSetIconGicon ::+    (MonadIO m, Gdk.DragContextK a, Gio.IconK b) =>+    a ->                                    -- context+    b ->                                    -- icon+    Int32 ->                                -- hot_x+    Int32 ->                                -- hot_y+    m ()+dragSetIconGicon context icon hot_x hot_y = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let icon' = unsafeManagedPtrCastPtr icon+    gtk_drag_set_icon_gicon context' icon' hot_x hot_y+    touchManagedPtr context+    touchManagedPtr icon+    return ()+++-- function gtk_drag_set_icon_default+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_drag_set_icon_default" gtk_drag_set_icon_default :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    IO ()+++dragSetIconDefault ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    m ()+dragSetIconDefault context = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    gtk_drag_set_icon_default context'+    touchManagedPtr context+    return ()+++-- function gtk_drag_get_source_widget+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_drag_get_source_widget" gtk_drag_get_source_widget :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    IO (Ptr Widget)+++dragGetSourceWidget ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    m Widget+dragGetSourceWidget context = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    result <- gtk_drag_get_source_widget context'+    checkUnexpectedReturnNULL "gtk_drag_get_source_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr context+    return result'+++-- function gtk_drag_finish+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "del", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "del", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "time_", 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 "gtk_drag_finish" gtk_drag_finish :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    CInt ->                                 -- success : TBasicType TBoolean+    CInt ->                                 -- del : TBasicType TBoolean+    Word32 ->                               -- time_ : TBasicType TUInt32+    IO ()+++dragFinish ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    Bool ->                                 -- success+    Bool ->                                 -- del+    Word32 ->                               -- time_+    m ()+dragFinish context success del time_ = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    let success' = (fromIntegral . fromEnum) success+    let del' = (fromIntegral . fromEnum) del+    gtk_drag_finish context' success' del' time_+    touchManagedPtr context+    return ()+++-- function gtk_drag_cancel+-- Args : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_drag_cancel" gtk_drag_cancel :: +    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    IO ()+++dragCancel ::+    (MonadIO m, Gdk.DragContextK a) =>+    a ->                                    -- context+    m ()+dragCancel context = liftIO $ do+    let context' = unsafeManagedPtrCastPtr context+    gtk_drag_cancel context'+    touchManagedPtr context+    return ()+++-- function gtk_distribute_natural_allocation+-- Args : [Arg {argName = "extra_space", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_requested_sizes", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sizes", argType = TInterface "Gtk" "RequestedSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "extra_space", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_requested_sizes", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sizes", argType = TInterface "Gtk" "RequestedSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_distribute_natural_allocation" gtk_distribute_natural_allocation :: +    Int32 ->                                -- extra_space : TBasicType TInt32+    Word32 ->                               -- n_requested_sizes : TBasicType TUInt32+    Ptr RequestedSize ->                    -- sizes : TInterface "Gtk" "RequestedSize"+    IO Int32+++distributeNaturalAllocation ::+    (MonadIO m) =>+    Int32 ->                                -- extra_space+    Word32 ->                               -- n_requested_sizes+    RequestedSize ->                        -- sizes+    m Int32+distributeNaturalAllocation extra_space n_requested_sizes sizes = liftIO $ do+    let sizes' = unsafeManagedPtrGetPtr sizes+    result <- gtk_distribute_natural_allocation extra_space n_requested_sizes sizes'+    touchManagedPtr sizes+    return result+++-- function gtk_disable_setlocale+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_disable_setlocale" gtk_disable_setlocale :: +    IO ()+++disableSetlocale ::+    (MonadIO m) =>+    m ()+disableSetlocale  = liftIO $ do+    gtk_disable_setlocale+    return ()+++-- function gtk_device_grab_remove+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_device_grab_remove" gtk_device_grab_remove :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Device ->                       -- device : TInterface "Gdk" "Device"+    IO ()+++deviceGrabRemove ::+    (MonadIO m, WidgetK a, Gdk.DeviceK b) =>+    a ->                                    -- widget+    b ->                                    -- device+    m ()+deviceGrabRemove widget device = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let device' = unsafeManagedPtrCastPtr device+    gtk_device_grab_remove widget' device'+    touchManagedPtr widget+    touchManagedPtr device+    return ()+++-- function gtk_device_grab_add+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "block_others", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "block_others", 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 "gtk_device_grab_add" gtk_device_grab_add :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Device ->                       -- device : TInterface "Gdk" "Device"+    CInt ->                                 -- block_others : TBasicType TBoolean+    IO ()+++deviceGrabAdd ::+    (MonadIO m, WidgetK a, Gdk.DeviceK b) =>+    a ->                                    -- widget+    b ->                                    -- device+    Bool ->                                 -- block_others+    m ()+deviceGrabAdd widget device block_others = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let device' = unsafeManagedPtrCastPtr device+    let block_others' = (fromIntegral . fromEnum) block_others+    gtk_device_grab_add widget' device' block_others'+    touchManagedPtr widget+    touchManagedPtr device+    return ()+++-- function gtk_css_provider_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_css_provider_error_quark" gtk_css_provider_error_quark :: +    IO Word32+++cssProviderErrorQuark ::+    (MonadIO m) =>+    m Word32+cssProviderErrorQuark  = liftIO $ do+    result <- gtk_css_provider_error_quark+    return result+++-- function gtk_check_version+-- Args : [Arg {argName = "required_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "required_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "required_micro", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "required_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "required_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "required_micro", 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 "gtk_check_version" gtk_check_version :: +    Word32 ->                               -- required_major : TBasicType TUInt32+    Word32 ->                               -- required_minor : TBasicType TUInt32+    Word32 ->                               -- required_micro : TBasicType TUInt32+    IO CString+++checkVersion ::+    (MonadIO m) =>+    Word32 ->                               -- required_major+    Word32 ->                               -- required_minor+    Word32 ->                               -- required_micro+    m T.Text+checkVersion required_major required_minor required_micro = liftIO $ do+    result <- gtk_check_version required_major required_minor required_micro+    checkUnexpectedReturnNULL "gtk_check_version" result+    result' <- cstringToText result+    return result'+++-- function gtk_cairo_transform_to_window+-- Args : [Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cairo_transform_to_window" gtk_cairo_transform_to_window :: +    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Window ->                       -- window : TInterface "Gdk" "Window"+    IO ()+++cairoTransformToWindow ::+    (MonadIO m, WidgetK a, Gdk.WindowK b) =>+    Cairo.Context ->                        -- cr+    a ->                                    -- widget+    b ->                                    -- window+    m ()+cairoTransformToWindow cr widget window = liftIO $ do+    let cr' = unsafeManagedPtrGetPtr cr+    let widget' = unsafeManagedPtrCastPtr widget+    let window' = unsafeManagedPtrCastPtr window+    gtk_cairo_transform_to_window cr' widget' window'+    touchManagedPtr cr+    touchManagedPtr widget+    touchManagedPtr window+    return ()+++-- function gtk_cairo_should_draw_window+-- Args : [Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cairo_should_draw_window" gtk_cairo_should_draw_window :: +    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Gdk.Window ->                       -- window : TInterface "Gdk" "Window"+    IO CInt+++cairoShouldDrawWindow ::+    (MonadIO m, Gdk.WindowK a) =>+    Cairo.Context ->                        -- cr+    a ->                                    -- window+    m Bool+cairoShouldDrawWindow cr window = liftIO $ do+    let cr' = unsafeManagedPtrGetPtr cr+    let window' = unsafeManagedPtrCastPtr window+    result <- gtk_cairo_should_draw_window cr' window'+    let result' = (/= 0) result+    touchManagedPtr cr+    touchManagedPtr window+    return result'+++-- function gtk_builder_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_error_quark" gtk_builder_error_quark :: +    IO Word32+++builderErrorQuark ::+    (MonadIO m) =>+    m Word32+builderErrorQuark  = liftIO $ do+    result <- gtk_builder_error_quark+    return result+++-- function gtk_bindings_activate_event+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventKey", 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 = "event", argType = TInterface "Gdk" "EventKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_bindings_activate_event" gtk_bindings_activate_event :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    Ptr Gdk.EventKey ->                     -- event : TInterface "Gdk" "EventKey"+    IO CInt+++bindingsActivateEvent ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- object+    Gdk.EventKey ->                         -- event+    m Bool+bindingsActivateEvent object event = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    let event' = unsafeManagedPtrGetPtr event+    result <- gtk_bindings_activate_event object' event'+    let result' = (/= 0) result+    touchManagedPtr object+    touchManagedPtr event+    return result'+++-- function gtk_bindings_activate+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", 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 = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_bindings_activate" gtk_bindings_activate :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO CInt+++bindingsActivate ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- object+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    m Bool+bindingsActivate object keyval modifiers = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    let modifiers' = gflagsToWord modifiers+    result <- gtk_bindings_activate object' keyval modifiers'+    let result' = (/= 0) result+    touchManagedPtr object+    return result'+++-- function gtk_binding_set_find+-- Args : [Arg {argName = "set_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "set_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "BindingSet"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_binding_set_find" gtk_binding_set_find :: +    CString ->                              -- set_name : TBasicType TUTF8+    IO (Ptr BindingSet)+++bindingSetFind ::+    (MonadIO m) =>+    T.Text ->                               -- set_name+    m BindingSet+bindingSetFind set_name_ = liftIO $ do+    set_name_' <- textToCString set_name_+    result <- gtk_binding_set_find set_name_'+    checkUnexpectedReturnNULL "gtk_binding_set_find" result+    result' <- (newPtr 64 BindingSet) result+    freeMem set_name_'+    return result'+++-- function gtk_binding_entry_skip+-- Args : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_binding_entry_skip" gtk_binding_entry_skip :: +    Ptr BindingSet ->                       -- binding_set : TInterface "Gtk" "BindingSet"+    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO ()+++bindingEntrySkip ::+    (MonadIO m) =>+    BindingSet ->                           -- binding_set+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    m ()+bindingEntrySkip binding_set keyval modifiers = liftIO $ do+    let binding_set' = unsafeManagedPtrGetPtr binding_set+    let modifiers' = gflagsToWord modifiers+    gtk_binding_entry_skip binding_set' keyval modifiers'+    touchManagedPtr binding_set+    return ()+++-- function gtk_binding_entry_remove+-- Args : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_binding_entry_remove" gtk_binding_entry_remove :: +    Ptr BindingSet ->                       -- binding_set : TInterface "Gtk" "BindingSet"+    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO ()+++bindingEntryRemove ::+    (MonadIO m) =>+    BindingSet ->                           -- binding_set+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    m ()+bindingEntryRemove binding_set keyval modifiers = liftIO $ do+    let binding_set' = unsafeManagedPtrGetPtr binding_set+    let modifiers' = gflagsToWord modifiers+    gtk_binding_entry_remove binding_set' keyval modifiers'+    touchManagedPtr binding_set+    return ()+++-- function gtk_binding_entry_add_signall+-- Args : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", 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 = "binding_args", argType = TGSList (TInterface "Gtk" "BindingArg"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", 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 = "binding_args", argType = TGSList (TInterface "Gtk" "BindingArg"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_binding_entry_add_signall" gtk_binding_entry_add_signall :: +    Ptr BindingSet ->                       -- binding_set : TInterface "Gtk" "BindingSet"+    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    CString ->                              -- signal_name : TBasicType TUTF8+    Ptr (GSList (Ptr BindingArg)) ->        -- binding_args : TGSList (TInterface "Gtk" "BindingArg")+    IO ()+++bindingEntryAddSignall ::+    (MonadIO m) =>+    BindingSet ->                           -- binding_set+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    T.Text ->                               -- signal_name+    [BindingArg] ->                         -- binding_args+    m ()+bindingEntryAddSignall binding_set keyval modifiers signal_name binding_args = liftIO $ do+    let binding_set' = unsafeManagedPtrGetPtr binding_set+    let modifiers' = gflagsToWord modifiers+    signal_name' <- textToCString signal_name+    let binding_args' = map unsafeManagedPtrGetPtr binding_args+    binding_args'' <- packGSList binding_args'+    gtk_binding_entry_add_signall binding_set' keyval modifiers' signal_name' binding_args''+    touchManagedPtr binding_set+    mapM_ touchManagedPtr binding_args+    freeMem signal_name'+    g_slist_free binding_args''+    return ()+++-- function gtk_binding_entry_add_signal_from_string+-- Args : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_desc", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "binding_set", argType = TInterface "Gtk" "BindingSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "signal_desc", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "TokenType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_binding_entry_add_signal_from_string" gtk_binding_entry_add_signal_from_string :: +    Ptr BindingSet ->                       -- binding_set : TInterface "Gtk" "BindingSet"+    CString ->                              -- signal_desc : TBasicType TUTF8+    IO CUInt+++bindingEntryAddSignalFromString ::+    (MonadIO m) =>+    BindingSet ->                           -- binding_set+    T.Text ->                               -- signal_desc+    m GLib.TokenType+bindingEntryAddSignalFromString binding_set signal_desc = liftIO $ do+    let binding_set' = unsafeManagedPtrGetPtr binding_set+    signal_desc' <- textToCString signal_desc+    result <- gtk_binding_entry_add_signal_from_string binding_set' signal_desc'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr binding_set+    freeMem signal_desc'+    return result'+++-- function gtk_alternative_dialog_button_order+-- Args : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_alternative_dialog_button_order" gtk_alternative_dialog_button_order :: +    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO CInt++{-# DEPRECATED alternativeDialogButtonOrder ["(Since version 3.10)","Deprecated"]#-}+alternativeDialogButtonOrder ::+    (MonadIO m, Gdk.ScreenK a) =>+    Maybe (a) ->                            -- screen+    m Bool+alternativeDialogButtonOrder screen = liftIO $ do+    maybeScreen <- case screen of+        Nothing -> return nullPtr+        Just jScreen -> do+            let jScreen' = unsafeManagedPtrCastPtr jScreen+            return jScreen'+    result <- gtk_alternative_dialog_button_order maybeScreen+    let result' = (/= 0) result+    whenJust screen touchManagedPtr+    return result'+++-- function gtk_accelerator_valid+-- Args : [Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "keyval", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modifiers", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_valid" gtk_accelerator_valid :: +    Word32 ->                               -- keyval : TBasicType TUInt32+    CUInt ->                                -- modifiers : TInterface "Gdk" "ModifierType"+    IO CInt+++acceleratorValid ::+    (MonadIO m) =>+    Word32 ->                               -- keyval+    [Gdk.ModifierType] ->                   -- modifiers+    m Bool+acceleratorValid keyval modifiers = liftIO $ do+    let modifiers' = gflagsToWord modifiers+    result <- gtk_accelerator_valid keyval modifiers'+    let result' = (/= 0) result+    return result'+++-- function gtk_accelerator_set_default_mod_mask+-- Args : [Arg {argName = "default_mod_mask", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "default_mod_mask", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_set_default_mod_mask" gtk_accelerator_set_default_mod_mask :: +    CUInt ->                                -- default_mod_mask : TInterface "Gdk" "ModifierType"+    IO ()+++acceleratorSetDefaultModMask ::+    (MonadIO m) =>+    [Gdk.ModifierType] ->                   -- default_mod_mask+    m ()+acceleratorSetDefaultModMask default_mod_mask = liftIO $ do+    let default_mod_mask' = gflagsToWord default_mod_mask+    gtk_accelerator_set_default_mod_mask default_mod_mask'+    return ()+++-- function gtk_accelerator_parse_with_keycode+-- Args : [Arg {argName = "accelerator", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "accelerator_codes", argType = TCArray True (-1) (-1) (TBasicType TUInt32), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accelerator", 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 "gtk_accelerator_parse_with_keycode" gtk_accelerator_parse_with_keycode :: +    CString ->                              -- accelerator : TBasicType TUTF8+    Ptr Word32 ->                           -- accelerator_key : TBasicType TUInt32+    Ptr (Ptr Word32) ->                     -- accelerator_codes : TCArray True (-1) (-1) (TBasicType TUInt32)+    Ptr CUInt ->                            -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO ()+++acceleratorParseWithKeycode ::+    (MonadIO m) =>+    T.Text ->                               -- accelerator+    m (Word32,[Word32],[Gdk.ModifierType])+acceleratorParseWithKeycode accelerator = liftIO $ do+    accelerator' <- textToCString accelerator+    accelerator_key <- allocMem :: IO (Ptr Word32)+    accelerator_codes <- allocMem :: IO (Ptr (Ptr Word32))+    accelerator_mods <- allocMem :: IO (Ptr CUInt)+    gtk_accelerator_parse_with_keycode accelerator' accelerator_key accelerator_codes accelerator_mods+    accelerator_key' <- peek accelerator_key+    accelerator_codes' <- peek accelerator_codes+    accelerator_codes'' <- unpackZeroTerminatedStorableArray accelerator_codes'+    freeMem accelerator_codes'+    accelerator_mods' <- peek accelerator_mods+    let accelerator_mods'' = wordToGFlags accelerator_mods'+    freeMem accelerator'+    freeMem accelerator_key+    freeMem accelerator_codes+    freeMem accelerator_mods+    return (accelerator_key', accelerator_codes'', accelerator_mods'')+++-- function gtk_accelerator_parse+-- Args : [Arg {argName = "accelerator", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accelerator", 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 "gtk_accelerator_parse" gtk_accelerator_parse :: +    CString ->                              -- accelerator : TBasicType TUTF8+    Ptr Word32 ->                           -- accelerator_key : TBasicType TUInt32+    Ptr CUInt ->                            -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO ()+++acceleratorParse ::+    (MonadIO m) =>+    T.Text ->                               -- accelerator+    m (Word32,[Gdk.ModifierType])+acceleratorParse accelerator = liftIO $ do+    accelerator' <- textToCString accelerator+    accelerator_key <- allocMem :: IO (Ptr Word32)+    accelerator_mods <- allocMem :: IO (Ptr CUInt)+    gtk_accelerator_parse accelerator' accelerator_key accelerator_mods+    accelerator_key' <- peek accelerator_key+    accelerator_mods' <- peek accelerator_mods+    let accelerator_mods'' = wordToGFlags accelerator_mods'+    freeMem accelerator'+    freeMem accelerator_key+    freeMem accelerator_mods+    return (accelerator_key', accelerator_mods'')+++-- function gtk_accelerator_name_with_keycode+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keycode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keycode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_name_with_keycode" gtk_accelerator_name_with_keycode :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Word32 ->                               -- accelerator_key : TBasicType TUInt32+    Word32 ->                               -- keycode : TBasicType TUInt32+    CUInt ->                                -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO CString+++acceleratorNameWithKeycode ::+    (MonadIO m, Gdk.DisplayK a) =>+    Maybe (a) ->                            -- display+    Word32 ->                               -- accelerator_key+    Word32 ->                               -- keycode+    [Gdk.ModifierType] ->                   -- accelerator_mods+    m T.Text+acceleratorNameWithKeycode display accelerator_key keycode accelerator_mods = liftIO $ do+    maybeDisplay <- case display of+        Nothing -> return nullPtr+        Just jDisplay -> do+            let jDisplay' = unsafeManagedPtrCastPtr jDisplay+            return jDisplay'+    let accelerator_mods' = gflagsToWord accelerator_mods+    result <- gtk_accelerator_name_with_keycode maybeDisplay accelerator_key keycode accelerator_mods'+    checkUnexpectedReturnNULL "gtk_accelerator_name_with_keycode" result+    result' <- cstringToText result+    freeMem result+    whenJust display touchManagedPtr+    return result'+++-- function gtk_accelerator_name+-- Args : [Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_name" gtk_accelerator_name :: +    Word32 ->                               -- accelerator_key : TBasicType TUInt32+    CUInt ->                                -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO CString+++acceleratorName ::+    (MonadIO m) =>+    Word32 ->                               -- accelerator_key+    [Gdk.ModifierType] ->                   -- accelerator_mods+    m T.Text+acceleratorName accelerator_key accelerator_mods = liftIO $ do+    let accelerator_mods' = gflagsToWord accelerator_mods+    result <- gtk_accelerator_name accelerator_key accelerator_mods'+    checkUnexpectedReturnNULL "gtk_accelerator_name" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gtk_accelerator_get_label_with_keycode+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keycode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "keycode", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_get_label_with_keycode" gtk_accelerator_get_label_with_keycode :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Word32 ->                               -- accelerator_key : TBasicType TUInt32+    Word32 ->                               -- keycode : TBasicType TUInt32+    CUInt ->                                -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO CString+++acceleratorGetLabelWithKeycode ::+    (MonadIO m, Gdk.DisplayK a) =>+    Maybe (a) ->                            -- display+    Word32 ->                               -- accelerator_key+    Word32 ->                               -- keycode+    [Gdk.ModifierType] ->                   -- accelerator_mods+    m T.Text+acceleratorGetLabelWithKeycode display accelerator_key keycode accelerator_mods = liftIO $ do+    maybeDisplay <- case display of+        Nothing -> return nullPtr+        Just jDisplay -> do+            let jDisplay' = unsafeManagedPtrCastPtr jDisplay+            return jDisplay'+    let accelerator_mods' = gflagsToWord accelerator_mods+    result <- gtk_accelerator_get_label_with_keycode maybeDisplay accelerator_key keycode accelerator_mods'+    checkUnexpectedReturnNULL "gtk_accelerator_get_label_with_keycode" result+    result' <- cstringToText result+    freeMem result+    whenJust display touchManagedPtr+    return result'+++-- function gtk_accelerator_get_label+-- Args : [Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_get_label" gtk_accelerator_get_label :: +    Word32 ->                               -- accelerator_key : TBasicType TUInt32+    CUInt ->                                -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO CString+++acceleratorGetLabel ::+    (MonadIO m) =>+    Word32 ->                               -- accelerator_key+    [Gdk.ModifierType] ->                   -- accelerator_mods+    m T.Text+acceleratorGetLabel accelerator_key accelerator_mods = liftIO $ do+    let accelerator_mods' = gflagsToWord accelerator_mods+    result <- gtk_accelerator_get_label accelerator_key accelerator_mods'+    checkUnexpectedReturnNULL "gtk_accelerator_get_label" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gtk_accelerator_get_default_mod_mask+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gdk" "ModifierType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accelerator_get_default_mod_mask" gtk_accelerator_get_default_mod_mask :: +    IO CUInt+++acceleratorGetDefaultModMask ::+    (MonadIO m) =>+    m [Gdk.ModifierType]+acceleratorGetDefaultModMask  = liftIO $ do+    result <- gtk_accelerator_get_default_mod_mask+    let result' = wordToGFlags result+    return result'+++-- function gtk_accel_groups_from_object+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", 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}]+-- returnType : TGSList (TInterface "Gtk" "AccelGroup")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_groups_from_object" gtk_accel_groups_from_object :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    IO (Ptr (GSList (Ptr AccelGroup)))+++accelGroupsFromObject ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- object+    m [AccelGroup]+accelGroupsFromObject object = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    result <- gtk_accel_groups_from_object object'+    checkUnexpectedReturnNULL "gtk_accel_groups_from_object" result+    result' <- unpackGSList result+    result'' <- mapM (newObject AccelGroup) result'+    touchManagedPtr object+    return result''+++-- function gtk_accel_groups_activate+-- Args : [Arg {argName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", 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 = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_groups_activate" gtk_accel_groups_activate :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    IO CInt+++accelGroupsActivate ::+    (MonadIO m, GObject.ObjectK a) =>+    a ->                                    -- object+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    m Bool+accelGroupsActivate object accel_key accel_mods = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    let accel_mods' = gflagsToWord accel_mods+    result <- gtk_accel_groups_activate object' accel_key accel_mods'+    let result' = (/= 0) result+    touchManagedPtr object+    return result'+++
+ GI/Gtk/Interfaces.hs view
@@ -0,0 +1,66 @@++{- |+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.Gtk.Interfaces+    (     module GI.Gtk.Interfaces.Actionable     ,+    module GI.Gtk.Interfaces.Activatable    ,+    module GI.Gtk.Interfaces.AppChooser     ,+    module GI.Gtk.Interfaces.Buildable      ,+    module GI.Gtk.Interfaces.CellAccessibleParent,+    module GI.Gtk.Interfaces.CellEditable   ,+    module GI.Gtk.Interfaces.CellLayout     ,+    module GI.Gtk.Interfaces.ColorChooser   ,+    module GI.Gtk.Interfaces.Editable       ,+    module GI.Gtk.Interfaces.FileChooser    ,+    module GI.Gtk.Interfaces.FontChooser    ,+    module GI.Gtk.Interfaces.Orientable     ,+    module GI.Gtk.Interfaces.PrintOperationPreview,+    module GI.Gtk.Interfaces.RecentChooser  ,+    module GI.Gtk.Interfaces.Scrollable     ,+    module GI.Gtk.Interfaces.StyleProvider  ,+    module GI.Gtk.Interfaces.ToolShell      ,+    module GI.Gtk.Interfaces.TreeDragDest   ,+    module GI.Gtk.Interfaces.TreeDragSource ,+    module GI.Gtk.Interfaces.TreeModel      ,+    module GI.Gtk.Interfaces.TreeSortable   ,+++    ) where++import GI.Gtk.Interfaces.Actionable+import GI.Gtk.Interfaces.Activatable+import GI.Gtk.Interfaces.AppChooser+import GI.Gtk.Interfaces.Buildable+import GI.Gtk.Interfaces.CellAccessibleParent+import GI.Gtk.Interfaces.CellEditable+import GI.Gtk.Interfaces.CellLayout+import GI.Gtk.Interfaces.ColorChooser+import GI.Gtk.Interfaces.Editable+import GI.Gtk.Interfaces.FileChooser+import GI.Gtk.Interfaces.FontChooser+import GI.Gtk.Interfaces.Orientable+import GI.Gtk.Interfaces.PrintOperationPreview+import GI.Gtk.Interfaces.RecentChooser+import GI.Gtk.Interfaces.Scrollable+import GI.Gtk.Interfaces.StyleProvider+import GI.Gtk.Interfaces.ToolShell+import GI.Gtk.Interfaces.TreeDragDest+import GI.Gtk.Interfaces.TreeDragSource+import GI.Gtk.Interfaces.TreeModel+import GI.Gtk.Interfaces.TreeSortable++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++
+ GI/Gtk/Interfaces/Actionable.hs view
@@ -0,0 +1,283 @@++{- |+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.Gtk.Interfaces.Actionable+    ( ++-- * Exported types+    Actionable(..)                          ,+    noActionable                            ,+    ActionableK                             ,+    toActionable                            ,+++ -- * Methods+-- ** actionableGetActionName+    actionableGetActionName                 ,+++-- ** actionableGetActionTargetValue+    actionableGetActionTargetValue          ,+++-- ** actionableSetActionName+    actionableSetActionName                 ,+++-- ** actionableSetActionTargetValue+    actionableSetActionTargetValue          ,+++-- ** actionableSetDetailedActionName+    actionableSetDetailedActionName         ,+++++ -- * Properties+-- ** ActionName+    ActionableActionNamePropertyInfo        ,+    constructActionableActionName           ,+    getActionableActionName                 ,+    setActionableActionName                 ,+++-- ** ActionTarget+    ActionableActionTargetPropertyInfo      ,+    constructActionableActionTarget         ,+    getActionableActionTarget               ,+    setActionableActionTarget               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface Actionable ++newtype Actionable = Actionable (ForeignPtr Actionable)+noActionable :: Maybe Actionable+noActionable = Nothing++-- VVV Prop "action-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionableActionName :: (MonadIO m, ActionableK o) => o -> m T.Text+getActionableActionName obj = liftIO $ getObjectPropertyString obj "action-name"++setActionableActionName :: (MonadIO m, ActionableK o) => o -> T.Text -> m ()+setActionableActionName obj val = liftIO $ setObjectPropertyString obj "action-name" val++constructActionableActionName :: T.Text -> IO ([Char], GValue)+constructActionableActionName val = constructObjectPropertyString "action-name" val++data ActionableActionNamePropertyInfo+instance AttrInfo ActionableActionNamePropertyInfo where+    type AttrAllowedOps ActionableActionNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionableActionNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionableActionNamePropertyInfo = ActionableK+    type AttrGetType ActionableActionNamePropertyInfo = T.Text+    type AttrLabel ActionableActionNamePropertyInfo = "Actionable::action-name"+    attrGet _ = getActionableActionName+    attrSet _ = setActionableActionName+    attrConstruct _ = constructActionableActionName++-- VVV Prop "action-target"+   -- Type: TVariant+   -- Flags: [PropertyReadable,PropertyWritable]++getActionableActionTarget :: (MonadIO m, ActionableK o) => o -> m GVariant+getActionableActionTarget obj = liftIO $ getObjectPropertyVariant obj "action-target"++setActionableActionTarget :: (MonadIO m, ActionableK o) => o -> GVariant -> m ()+setActionableActionTarget obj val = liftIO $ setObjectPropertyVariant obj "action-target" val++constructActionableActionTarget :: GVariant -> IO ([Char], GValue)+constructActionableActionTarget val = constructObjectPropertyVariant "action-target" val++data ActionableActionTargetPropertyInfo+instance AttrInfo ActionableActionTargetPropertyInfo where+    type AttrAllowedOps ActionableActionTargetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionableActionTargetPropertyInfo = (~) GVariant+    type AttrBaseTypeConstraint ActionableActionTargetPropertyInfo = ActionableK+    type AttrGetType ActionableActionTargetPropertyInfo = GVariant+    type AttrLabel ActionableActionTargetPropertyInfo = "Actionable::action-target"+    attrGet _ = getActionableActionTarget+    attrSet _ = setActionableActionTarget+    attrConstruct _ = constructActionableActionTarget++type instance AttributeList Actionable = ActionableAttributeList+type ActionableAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Actionable = ActionableSignalList+type ActionableSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_actionable_get_type"+    c_gtk_actionable_get_type :: IO GType++type instance ParentTypes Actionable = ActionableParentTypes+type ActionableParentTypes = '[Widget, GObject.Object]++instance GObject Actionable where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_actionable_get_type+    ++class GObject o => ActionableK o+instance (GObject o, IsDescendantOf Actionable o) => ActionableK o++toActionable :: ActionableK o => o -> IO Actionable+toActionable = unsafeCastTo Actionable++-- method Actionable::get_action_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_actionable_get_action_name" gtk_actionable_get_action_name :: +    Ptr Actionable ->                       -- _obj : TInterface "Gtk" "Actionable"+    IO CString+++actionableGetActionName ::+    (MonadIO m, ActionableK a) =>+    a ->                                    -- _obj+    m T.Text+actionableGetActionName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_actionable_get_action_name _obj'+    checkUnexpectedReturnNULL "gtk_actionable_get_action_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Actionable::get_action_target_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TVariant+-- throws : False+-- Skip return : False++foreign import ccall "gtk_actionable_get_action_target_value" gtk_actionable_get_action_target_value :: +    Ptr Actionable ->                       -- _obj : TInterface "Gtk" "Actionable"+    IO (Ptr GVariant)+++actionableGetActionTargetValue ::+    (MonadIO m, ActionableK a) =>+    a ->                                    -- _obj+    m GVariant+actionableGetActionTargetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_actionable_get_action_target_value _obj'+    checkUnexpectedReturnNULL "gtk_actionable_get_action_target_value" result+    result' <- newGVariantFromPtr result+    touchManagedPtr _obj+    return result'++-- method Actionable::set_action_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", 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 "Gtk" "Actionable", 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 "gtk_actionable_set_action_name" gtk_actionable_set_action_name :: +    Ptr Actionable ->                       -- _obj : TInterface "Gtk" "Actionable"+    CString ->                              -- action_name : TBasicType TUTF8+    IO ()+++actionableSetActionName ::+    (MonadIO m, ActionableK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m ()+actionableSetActionName _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    gtk_actionable_set_action_name _obj' action_name'+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method Actionable::set_action_target_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_value", argType = TVariant, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_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 "gtk_actionable_set_action_target_value" gtk_actionable_set_action_target_value :: +    Ptr Actionable ->                       -- _obj : TInterface "Gtk" "Actionable"+    Ptr GVariant ->                         -- target_value : TVariant+    IO ()+++actionableSetActionTargetValue ::+    (MonadIO m, ActionableK a) =>+    a ->                                    -- _obj+    GVariant ->                             -- target_value+    m ()+actionableSetActionTargetValue _obj target_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let target_value' = unsafeManagedPtrGetPtr target_value+    gtk_actionable_set_action_target_value _obj' target_value'+    touchManagedPtr _obj+    return ()++-- method Actionable::set_detailed_action_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Actionable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_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 "gtk_actionable_set_detailed_action_name" gtk_actionable_set_detailed_action_name :: +    Ptr Actionable ->                       -- _obj : TInterface "Gtk" "Actionable"+    CString ->                              -- detailed_action_name : TBasicType TUTF8+    IO ()+++actionableSetDetailedActionName ::+    (MonadIO m, ActionableK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- detailed_action_name+    m ()+actionableSetDetailedActionName _obj detailed_action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    detailed_action_name' <- textToCString detailed_action_name+    gtk_actionable_set_detailed_action_name _obj' detailed_action_name'+    touchManagedPtr _obj+    freeMem detailed_action_name'+    return ()++
+ GI/Gtk/Interfaces/Actionable.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Interfaces.Actionable where++import Prelude ()+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 Actionable = Actionable (ForeignPtr Actionable)+data ActionableActionNamePropertyInfo+data ActionableActionTargetPropertyInfo+instance GObject Actionable where+class GObject o => ActionableK o+instance (GObject o, IsDescendantOf Actionable o) => ActionableK o
+ GI/Gtk/Interfaces/Activatable.hs view
@@ -0,0 +1,318 @@++{- |+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.Gtk.Interfaces.Activatable+    ( ++-- * Exported types+    Activatable(..)                         ,+    noActivatable                           ,+    ActivatableK                            ,+    toActivatable                           ,+++ -- * Methods+-- ** activatableDoSetRelatedAction+    activatableDoSetRelatedAction           ,+++-- ** activatableGetRelatedAction+    activatableGetRelatedAction             ,+++-- ** activatableGetUseActionAppearance+    activatableGetUseActionAppearance       ,+++-- ** activatableSetRelatedAction+    activatableSetRelatedAction             ,+++-- ** activatableSetUseActionAppearance+    activatableSetUseActionAppearance       ,+++-- ** activatableSyncActionProperties+    activatableSyncActionProperties         ,+++++ -- * Properties+-- ** RelatedAction+    ActivatableRelatedActionPropertyInfo    ,+    constructActivatableRelatedAction       ,+    getActivatableRelatedAction             ,+    setActivatableRelatedAction             ,+++-- ** UseActionAppearance+    ActivatableUseActionAppearancePropertyInfo,+    constructActivatableUseActionAppearance ,+    getActivatableUseActionAppearance       ,+    setActivatableUseActionAppearance       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface Activatable ++newtype Activatable = Activatable (ForeignPtr Activatable)+noActivatable :: Maybe Activatable+noActivatable = Nothing++-- VVV Prop "related-action"+   -- Type: TInterface "Gtk" "Action"+   -- Flags: [PropertyReadable,PropertyWritable]++getActivatableRelatedAction :: (MonadIO m, ActivatableK o) => o -> m Action+getActivatableRelatedAction obj = liftIO $ getObjectPropertyObject obj "related-action" Action++setActivatableRelatedAction :: (MonadIO m, ActivatableK o, ActionK a) => o -> a -> m ()+setActivatableRelatedAction obj val = liftIO $ setObjectPropertyObject obj "related-action" val++constructActivatableRelatedAction :: (ActionK a) => a -> IO ([Char], GValue)+constructActivatableRelatedAction val = constructObjectPropertyObject "related-action" val++data ActivatableRelatedActionPropertyInfo+instance AttrInfo ActivatableRelatedActionPropertyInfo where+    type AttrAllowedOps ActivatableRelatedActionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActivatableRelatedActionPropertyInfo = ActionK+    type AttrBaseTypeConstraint ActivatableRelatedActionPropertyInfo = ActivatableK+    type AttrGetType ActivatableRelatedActionPropertyInfo = Action+    type AttrLabel ActivatableRelatedActionPropertyInfo = "Activatable::related-action"+    attrGet _ = getActivatableRelatedAction+    attrSet _ = setActivatableRelatedAction+    attrConstruct _ = constructActivatableRelatedAction++-- VVV Prop "use-action-appearance"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActivatableUseActionAppearance :: (MonadIO m, ActivatableK o) => o -> m Bool+getActivatableUseActionAppearance obj = liftIO $ getObjectPropertyBool obj "use-action-appearance"++setActivatableUseActionAppearance :: (MonadIO m, ActivatableK o) => o -> Bool -> m ()+setActivatableUseActionAppearance obj val = liftIO $ setObjectPropertyBool obj "use-action-appearance" val++constructActivatableUseActionAppearance :: Bool -> IO ([Char], GValue)+constructActivatableUseActionAppearance val = constructObjectPropertyBool "use-action-appearance" val++data ActivatableUseActionAppearancePropertyInfo+instance AttrInfo ActivatableUseActionAppearancePropertyInfo where+    type AttrAllowedOps ActivatableUseActionAppearancePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActivatableUseActionAppearancePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActivatableUseActionAppearancePropertyInfo = ActivatableK+    type AttrGetType ActivatableUseActionAppearancePropertyInfo = Bool+    type AttrLabel ActivatableUseActionAppearancePropertyInfo = "Activatable::use-action-appearance"+    attrGet _ = getActivatableUseActionAppearance+    attrSet _ = setActivatableUseActionAppearance+    attrConstruct _ = constructActivatableUseActionAppearance++type instance AttributeList Activatable = ActivatableAttributeList+type ActivatableAttributeList = ('[ '("related-action", ActivatableRelatedActionPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo)] :: [(Symbol, *)])++type instance SignalList Activatable = ActivatableSignalList+type ActivatableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_activatable_get_type"+    c_gtk_activatable_get_type :: IO GType++type instance ParentTypes Activatable = ActivatableParentTypes+type ActivatableParentTypes = '[GObject.Object]++instance GObject Activatable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_activatable_get_type+    ++class GObject o => ActivatableK o+instance (GObject o, IsDescendantOf Activatable o) => ActivatableK o++toActivatable :: ActivatableK o => o -> IO Activatable+toActivatable = unsafeCastTo Activatable++-- method Activatable::do_set_related_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_activatable_do_set_related_action" gtk_activatable_do_set_related_action :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED activatableDoSetRelatedAction ["(Since version 3.10)"]#-}+activatableDoSetRelatedAction ::+    (MonadIO m, ActivatableK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+activatableDoSetRelatedAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    gtk_activatable_do_set_related_action _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method Activatable::get_related_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_activatable_get_related_action" gtk_activatable_get_related_action :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    IO (Ptr Action)++{-# DEPRECATED activatableGetRelatedAction ["(Since version 3.10)"]#-}+activatableGetRelatedAction ::+    (MonadIO m, ActivatableK a) =>+    a ->                                    -- _obj+    m Action+activatableGetRelatedAction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_activatable_get_related_action _obj'+    checkUnexpectedReturnNULL "gtk_activatable_get_related_action" result+    result' <- (newObject Action) result+    touchManagedPtr _obj+    return result'++-- method Activatable::get_use_action_appearance+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_activatable_get_use_action_appearance" gtk_activatable_get_use_action_appearance :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    IO CInt++{-# DEPRECATED activatableGetUseActionAppearance ["(Since version 3.10)"]#-}+activatableGetUseActionAppearance ::+    (MonadIO m, ActivatableK a) =>+    a ->                                    -- _obj+    m Bool+activatableGetUseActionAppearance _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_activatable_get_use_action_appearance _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Activatable::set_related_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_activatable_set_related_action" gtk_activatable_set_related_action :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED activatableSetRelatedAction ["(Since version 3.10)"]#-}+activatableSetRelatedAction ::+    (MonadIO m, ActivatableK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+activatableSetRelatedAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    gtk_activatable_set_related_action _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method Activatable::set_use_action_appearance+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_appearance", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_appearance", 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 "gtk_activatable_set_use_action_appearance" gtk_activatable_set_use_action_appearance :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    CInt ->                                 -- use_appearance : TBasicType TBoolean+    IO ()++{-# DEPRECATED activatableSetUseActionAppearance ["(Since version 3.10)"]#-}+activatableSetUseActionAppearance ::+    (MonadIO m, ActivatableK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_appearance+    m ()+activatableSetUseActionAppearance _obj use_appearance = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_appearance' = (fromIntegral . fromEnum) use_appearance+    gtk_activatable_set_use_action_appearance _obj' use_appearance'+    touchManagedPtr _obj+    return ()++-- method Activatable::sync_action_properties+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Activatable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_activatable_sync_action_properties" gtk_activatable_sync_action_properties :: +    Ptr Activatable ->                      -- _obj : TInterface "Gtk" "Activatable"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED activatableSyncActionProperties ["(Since version 3.10)"]#-}+activatableSyncActionProperties ::+    (MonadIO m, ActivatableK a, ActionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- action+    m ()+activatableSyncActionProperties _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAction <- case action of+        Nothing -> return nullPtr+        Just jAction -> do+            let jAction' = unsafeManagedPtrCastPtr jAction+            return jAction'+    gtk_activatable_sync_action_properties _obj' maybeAction+    touchManagedPtr _obj+    whenJust action touchManagedPtr+    return ()++
+ GI/Gtk/Interfaces/Activatable.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Interfaces.Activatable where++import Prelude ()+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 Activatable = Activatable (ForeignPtr Activatable)+data ActivatableRelatedActionPropertyInfo+data ActivatableUseActionAppearancePropertyInfo+instance GObject Activatable where+class GObject o => ActivatableK o+instance (GObject o, IsDescendantOf Activatable o) => ActivatableK o
+ GI/Gtk/Interfaces/AppChooser.hs view
@@ -0,0 +1,183 @@++{- |+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.Gtk.Interfaces.AppChooser+    ( ++-- * Exported types+    AppChooser(..)                          ,+    noAppChooser                            ,+    AppChooserK                             ,+    toAppChooser                            ,+++ -- * Methods+-- ** appChooserGetAppInfo+    appChooserGetAppInfo                    ,+++-- ** appChooserGetContentType+    appChooserGetContentType                ,+++-- ** appChooserRefresh+    appChooserRefresh                       ,+++++ -- * Properties+-- ** ContentType+    AppChooserContentTypePropertyInfo       ,+    constructAppChooserContentType          ,+    getAppChooserContentType                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++-- interface AppChooser ++newtype AppChooser = AppChooser (ForeignPtr AppChooser)+noAppChooser :: Maybe AppChooser+noAppChooser = Nothing++-- VVV Prop "content-type"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getAppChooserContentType :: (MonadIO m, AppChooserK o) => o -> m T.Text+getAppChooserContentType obj = liftIO $ getObjectPropertyString obj "content-type"++constructAppChooserContentType :: T.Text -> IO ([Char], GValue)+constructAppChooserContentType val = constructObjectPropertyString "content-type" val++data AppChooserContentTypePropertyInfo+instance AttrInfo AppChooserContentTypePropertyInfo where+    type AttrAllowedOps AppChooserContentTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserContentTypePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AppChooserContentTypePropertyInfo = AppChooserK+    type AttrGetType AppChooserContentTypePropertyInfo = T.Text+    type AttrLabel AppChooserContentTypePropertyInfo = "AppChooser::content-type"+    attrGet _ = getAppChooserContentType+    attrSet _ = undefined+    attrConstruct _ = constructAppChooserContentType++type instance AttributeList AppChooser = AppChooserAttributeList+type AppChooserAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("content-type", AppChooserContentTypePropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList AppChooser = AppChooserSignalList+type AppChooserSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_app_chooser_get_type"+    c_gtk_app_chooser_get_type :: IO GType++type instance ParentTypes AppChooser = AppChooserParentTypes+type AppChooserParentTypes = '[Widget, GObject.Object]++instance GObject AppChooser where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_app_chooser_get_type+    ++class GObject o => AppChooserK o+instance (GObject o, IsDescendantOf AppChooser o) => AppChooserK o++toAppChooser :: AppChooserK o => o -> IO AppChooser+toAppChooser = unsafeCastTo AppChooser++-- method AppChooser::get_app_info+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "AppInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_get_app_info" gtk_app_chooser_get_app_info :: +    Ptr AppChooser ->                       -- _obj : TInterface "Gtk" "AppChooser"+    IO (Ptr Gio.AppInfo)+++appChooserGetAppInfo ::+    (MonadIO m, AppChooserK a) =>+    a ->                                    -- _obj+    m Gio.AppInfo+appChooserGetAppInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_get_app_info _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_get_app_info" result+    result' <- (wrapObject Gio.AppInfo) result+    touchManagedPtr _obj+    return result'++-- method AppChooser::get_content_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_get_content_type" gtk_app_chooser_get_content_type :: +    Ptr AppChooser ->                       -- _obj : TInterface "Gtk" "AppChooser"+    IO CString+++appChooserGetContentType ::+    (MonadIO m, AppChooserK a) =>+    a ->                                    -- _obj+    m T.Text+appChooserGetContentType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_get_content_type _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_get_content_type" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method AppChooser::refresh+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_refresh" gtk_app_chooser_refresh :: +    Ptr AppChooser ->                       -- _obj : TInterface "Gtk" "AppChooser"+    IO ()+++appChooserRefresh ::+    (MonadIO m, AppChooserK a) =>+    a ->                                    -- _obj+    m ()+appChooserRefresh _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_app_chooser_refresh _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/AppChooser.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Interfaces.AppChooser where++import Prelude ()+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 AppChooser = AppChooser (ForeignPtr AppChooser)+data AppChooserContentTypePropertyInfo+instance GObject AppChooser where+class GObject o => AppChooserK o+instance (GObject o, IsDescendantOf AppChooser o) => AppChooserK o
+ GI/Gtk/Interfaces/Buildable.hs view
@@ -0,0 +1,462 @@++{- |+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.Gtk.Interfaces.Buildable+    ( ++-- * Exported types+    Buildable(..)                           ,+    noBuildable                             ,+    BuildableK                              ,+    toBuildable                             ,+++ -- * Methods+-- ** buildableAddChild+    buildableAddChild                       ,+++-- ** buildableConstructChild+    buildableConstructChild                 ,+++-- ** buildableCustomFinished+    buildableCustomFinished                 ,+++-- ** buildableCustomTagEnd+    buildableCustomTagEnd                   ,+++-- ** buildableCustomTagStart+    buildableCustomTagStart                 ,+++-- ** buildableGetInternalChild+    buildableGetInternalChild               ,+++-- ** buildableGetName+    buildableGetName                        ,+++-- ** buildableParserFinished+    buildableParserFinished                 ,+++-- ** buildableSetBuildableProperty+    buildableSetBuildableProperty           ,+++-- ** buildableSetName+    buildableSetName                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface Buildable ++newtype Buildable = Buildable (ForeignPtr Buildable)+noBuildable :: Maybe Buildable+noBuildable = Nothing++type instance AttributeList Buildable = BuildableAttributeList+type BuildableAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Buildable = BuildableSignalList+type BuildableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_buildable_get_type"+    c_gtk_buildable_get_type :: IO GType++type instance ParentTypes Buildable = BuildableParentTypes+type BuildableParentTypes = '[GObject.Object]++instance GObject Buildable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_buildable_get_type+    ++class GObject o => BuildableK o+instance (GObject o, IsDescendantOf Buildable o) => BuildableK o++toBuildable :: BuildableK o => o -> IO Buildable+toBuildable = unsafeCastTo Buildable++-- method Buildable::add_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", 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 "gtk_buildable_add_child" gtk_buildable_add_child :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- type : TBasicType TUTF8+    IO ()+++buildableAddChild ::+    (MonadIO m, BuildableK a, BuilderK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    c ->                                    -- child+    Maybe (T.Text) ->                       -- type+    m ()+buildableAddChild _obj builder child type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    let child' = unsafeManagedPtrCastPtr child+    maybeType_ <- case type_ of+        Nothing -> return nullPtr+        Just jType_ -> do+            jType_' <- textToCString jType_+            return jType_'+    gtk_buildable_add_child _obj' builder' child' maybeType_+    touchManagedPtr _obj+    touchManagedPtr builder+    touchManagedPtr child+    freeMem maybeType_+    return ()++-- method Buildable::construct_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", 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 "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", 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 "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_buildable_construct_child" gtk_buildable_construct_child :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GObject.Object)+++buildableConstructChild ::+    (MonadIO m, BuildableK a, BuilderK b) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    T.Text ->                               -- name+    m GObject.Object+buildableConstructChild _obj builder name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    name' <- textToCString name+    result <- gtk_buildable_construct_child _obj' builder' name'+    checkUnexpectedReturnNULL "gtk_buildable_construct_child" result+    result' <- (wrapObject GObject.Object) result+    touchManagedPtr _obj+    touchManagedPtr builder+    freeMem name'+    return result'++-- method Buildable::custom_finished+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", argType = TBasicType TUTF8, 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 "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", argType = TBasicType TUTF8, 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 "gtk_buildable_custom_finished" gtk_buildable_custom_finished :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- tagname : TBasicType TUTF8+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++buildableCustomFinished ::+    (MonadIO m, BuildableK a, BuilderK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    Maybe (c) ->                            -- child+    T.Text ->                               -- tagname+    Ptr () ->                               -- data+    m ()+buildableCustomFinished _obj builder child tagname data_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    maybeChild <- case child of+        Nothing -> return nullPtr+        Just jChild -> do+            let jChild' = unsafeManagedPtrCastPtr jChild+            return jChild'+    tagname' <- textToCString tagname+    gtk_buildable_custom_finished _obj' builder' maybeChild tagname' data_+    touchManagedPtr _obj+    touchManagedPtr builder+    whenJust child touchManagedPtr+    freeMem tagname'+    return ()++-- method Buildable::custom_tag_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", argType = TBasicType TUTF8, 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 "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", argType = TBasicType TUTF8, 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 "gtk_buildable_custom_tag_end" gtk_buildable_custom_tag_end :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- tagname : TBasicType TUTF8+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++buildableCustomTagEnd ::+    (MonadIO m, BuildableK a, BuilderK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    Maybe (c) ->                            -- child+    T.Text ->                               -- tagname+    Ptr () ->                               -- data+    m ()+buildableCustomTagEnd _obj builder child tagname data_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    maybeChild <- case child of+        Nothing -> return nullPtr+        Just jChild -> do+            let jChild' = unsafeManagedPtrCastPtr jChild+            return jChild'+    tagname' <- textToCString tagname+    gtk_buildable_custom_tag_end _obj' builder' maybeChild tagname' data_+    touchManagedPtr _obj+    touchManagedPtr builder+    whenJust child touchManagedPtr+    freeMem tagname'+    return ()++-- method Buildable::custom_tag_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parser", argType = TInterface "GLib" "MarkupParser", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tagname", 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 "gtk_buildable_custom_tag_start" gtk_buildable_custom_tag_start :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- tagname : TBasicType TUTF8+    Ptr GLib.MarkupParser ->                -- parser : TInterface "GLib" "MarkupParser"+    Ptr (Ptr ()) ->                         -- data : TBasicType TVoid+    IO CInt+++buildableCustomTagStart ::+    (MonadIO m, BuildableK a, BuilderK b, GObject.ObjectK c) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    Maybe (c) ->                            -- child+    T.Text ->                               -- tagname+    m (Bool,GLib.MarkupParser,(Ptr ()))+buildableCustomTagStart _obj builder child tagname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    maybeChild <- case child of+        Nothing -> return nullPtr+        Just jChild -> do+            let jChild' = unsafeManagedPtrCastPtr jChild+            return jChild'+    tagname' <- textToCString tagname+    parser <- callocBytes 40 :: IO (Ptr GLib.MarkupParser)+    data_ <- allocMem :: IO (Ptr (Ptr ()))+    result <- gtk_buildable_custom_tag_start _obj' builder' maybeChild tagname' parser data_+    let result' = (/= 0) result+    parser' <- (wrapPtr GLib.MarkupParser) parser+    data_' <- peek data_+    touchManagedPtr _obj+    touchManagedPtr builder+    whenJust child touchManagedPtr+    freeMem tagname'+    freeMem data_+    return (result', parser', data_')++-- method Buildable::get_internal_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "childname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "childname", 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 "gtk_buildable_get_internal_child" gtk_buildable_get_internal_child :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    CString ->                              -- childname : TBasicType TUTF8+    IO (Ptr GObject.Object)+++buildableGetInternalChild ::+    (MonadIO m, BuildableK a, BuilderK b) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    T.Text ->                               -- childname+    m GObject.Object+buildableGetInternalChild _obj builder childname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    childname' <- textToCString childname+    result <- gtk_buildable_get_internal_child _obj' builder' childname'+    checkUnexpectedReturnNULL "gtk_buildable_get_internal_child" result+    result' <- (newObject GObject.Object) result+    touchManagedPtr _obj+    touchManagedPtr builder+    freeMem childname'+    return result'++-- method Buildable::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_buildable_get_name" gtk_buildable_get_name :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    IO CString+++buildableGetName ::+    (MonadIO m, BuildableK a) =>+    a ->                                    -- _obj+    m T.Text+buildableGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_buildable_get_name _obj'+    checkUnexpectedReturnNULL "gtk_buildable_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Buildable::parser_finished+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_buildable_parser_finished" gtk_buildable_parser_finished :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    IO ()+++buildableParserFinished ::+    (MonadIO m, BuildableK a, BuilderK b) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    m ()+buildableParserFinished _obj builder = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    gtk_buildable_parser_finished _obj' builder'+    touchManagedPtr _obj+    touchManagedPtr builder+    return ()++-- method Buildable::set_buildable_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", 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 = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "builder", argType = TInterface "Gtk" "Builder", 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 = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_buildable_set_buildable_property" gtk_buildable_set_buildable_property :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    Ptr Builder ->                          -- builder : TInterface "Gtk" "Builder"+    CString ->                              -- name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++buildableSetBuildableProperty ::+    (MonadIO m, BuildableK a, BuilderK b) =>+    a ->                                    -- _obj+    b ->                                    -- builder+    T.Text ->                               -- name+    GValue ->                               -- value+    m ()+buildableSetBuildableProperty _obj builder name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let builder' = unsafeManagedPtrCastPtr builder+    name' <- textToCString name+    let value' = unsafeManagedPtrGetPtr value+    gtk_buildable_set_buildable_property _obj' builder' name' value'+    touchManagedPtr _obj+    touchManagedPtr builder+    touchManagedPtr value+    freeMem name'+    return ()++-- method Buildable::set_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Buildable", 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 "Gtk" "Buildable", 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 "gtk_buildable_set_name" gtk_buildable_set_name :: +    Ptr Buildable ->                        -- _obj : TInterface "Gtk" "Buildable"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++buildableSetName ::+    (MonadIO m, BuildableK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m ()+buildableSetName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gtk_buildable_set_name _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++
+ GI/Gtk/Interfaces/Buildable.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Interfaces.Buildable where++import Prelude ()+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 Buildable = Buildable (ForeignPtr Buildable)+instance GObject Buildable where+class GObject o => BuildableK o+instance (GObject o, IsDescendantOf Buildable o) => BuildableK o
+ GI/Gtk/Interfaces/CellAccessibleParent.hs view
@@ -0,0 +1,360 @@++{- |+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.Gtk.Interfaces.CellAccessibleParent+    ( ++-- * Exported types+    CellAccessibleParent(..)                ,+    noCellAccessibleParent                  ,+    CellAccessibleParentK                   ,+++ -- * Methods+-- ** cellAccessibleParentActivate+    cellAccessibleParentActivate            ,+++-- ** cellAccessibleParentEdit+    cellAccessibleParentEdit                ,+++-- ** cellAccessibleParentExpandCollapse+    cellAccessibleParentExpandCollapse      ,+++-- ** cellAccessibleParentGetCellArea+    cellAccessibleParentGetCellArea         ,+++-- ** cellAccessibleParentGetCellExtents+    cellAccessibleParentGetCellExtents      ,+++-- ** cellAccessibleParentGetChildIndex+    cellAccessibleParentGetChildIndex       ,+++-- ** cellAccessibleParentGetRendererState+    cellAccessibleParentGetRendererState    ,+++-- ** cellAccessibleParentGrabFocus+    cellAccessibleParentGrabFocus           ,+++-- ** cellAccessibleParentUpdateRelationset+    cellAccessibleParentUpdateRelationset   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.Gdk as Gdk++-- interface CellAccessibleParent ++newtype CellAccessibleParent = CellAccessibleParent (ForeignPtr CellAccessibleParent)+noCellAccessibleParent :: Maybe CellAccessibleParent+noCellAccessibleParent = Nothing++type instance AttributeList CellAccessibleParent = CellAccessibleParentAttributeList+type CellAccessibleParentAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList CellAccessibleParent = CellAccessibleParentSignalList+type CellAccessibleParentSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => CellAccessibleParentK a+instance (ForeignPtrNewtype o, IsDescendantOf CellAccessibleParent o) => CellAccessibleParentK o+type instance ParentTypes CellAccessibleParent = CellAccessibleParentParentTypes+type CellAccessibleParentParentTypes = '[]++-- method CellAccessibleParent::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_activate" gtk_cell_accessible_parent_activate :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO ()+++cellAccessibleParentActivate ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m ()+cellAccessibleParentActivate _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    gtk_cell_accessible_parent_activate _obj' cell'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellAccessibleParent::edit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_edit" gtk_cell_accessible_parent_edit :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO ()+++cellAccessibleParentEdit ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m ()+cellAccessibleParentEdit _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    gtk_cell_accessible_parent_edit _obj' cell'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellAccessibleParent::expand_collapse+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_expand_collapse" gtk_cell_accessible_parent_expand_collapse :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO ()+++cellAccessibleParentExpandCollapse ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m ()+cellAccessibleParentExpandCollapse _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    gtk_cell_accessible_parent_expand_collapse _obj' cell'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellAccessibleParent::get_cell_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_get_cell_area" gtk_cell_accessible_parent_get_cell_area :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    Ptr Gdk.Rectangle ->                    -- cell_rect : TInterface "Gdk" "Rectangle"+    IO ()+++cellAccessibleParentGetCellArea ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Gdk.Rectangle ->                        -- cell_rect+    m ()+cellAccessibleParentGetCellArea _obj cell cell_rect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    let cell_rect' = unsafeManagedPtrGetPtr cell_rect+    gtk_cell_accessible_parent_get_cell_area _obj' cell' cell_rect'+    touchManagedPtr _obj+    touchManagedPtr cell+    touchManagedPtr cell_rect+    return ()++-- method CellAccessibleParent::get_cell_extents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "coord_type", argType = TInterface "Atk" "CoordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "coord_type", argType = TInterface "Atk" "CoordType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_get_cell_extents" gtk_cell_accessible_parent_get_cell_extents :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    CUInt ->                                -- coord_type : TInterface "Atk" "CoordType"+    IO ()+++cellAccessibleParentGetCellExtents ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Int32 ->                                -- x+    Int32 ->                                -- y+    Int32 ->                                -- width+    Int32 ->                                -- height+    Atk.CoordType ->                        -- coord_type+    m ()+cellAccessibleParentGetCellExtents _obj cell x y width height coord_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    let coord_type' = (fromIntegral . fromEnum) coord_type+    gtk_cell_accessible_parent_get_cell_extents _obj' cell' x y width height coord_type'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellAccessibleParent::get_child_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_get_child_index" gtk_cell_accessible_parent_get_child_index :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO Int32+++cellAccessibleParentGetChildIndex ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m Int32+cellAccessibleParentGetChildIndex _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    result <- gtk_cell_accessible_parent_get_child_index _obj' cell'+    touchManagedPtr _obj+    touchManagedPtr cell+    return result++-- method CellAccessibleParent::get_renderer_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellRendererState"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_get_renderer_state" gtk_cell_accessible_parent_get_renderer_state :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO CUInt+++cellAccessibleParentGetRendererState ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m [CellRendererState]+cellAccessibleParentGetRendererState _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    result <- gtk_cell_accessible_parent_get_renderer_state _obj' cell'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    touchManagedPtr cell+    return result'++-- method CellAccessibleParent::grab_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_grab_focus" gtk_cell_accessible_parent_grab_focus :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    IO CInt+++cellAccessibleParentGrabFocus ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m Bool+cellAccessibleParentGrabFocus _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    result <- gtk_cell_accessible_parent_grab_focus _obj' cell'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr cell+    return result'++-- method CellAccessibleParent::update_relationset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relationset", argType = TInterface "Atk" "RelationSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAccessibleParent", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relationset", argType = TInterface "Atk" "RelationSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_accessible_parent_update_relationset" gtk_cell_accessible_parent_update_relationset :: +    Ptr CellAccessibleParent ->             -- _obj : TInterface "Gtk" "CellAccessibleParent"+    Ptr CellAccessible ->                   -- cell : TInterface "Gtk" "CellAccessible"+    Ptr Atk.RelationSet ->                  -- relationset : TInterface "Atk" "RelationSet"+    IO ()+++cellAccessibleParentUpdateRelationset ::+    (MonadIO m, CellAccessibleParentK a, CellAccessibleK b, Atk.RelationSetK c) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    c ->                                    -- relationset+    m ()+cellAccessibleParentUpdateRelationset _obj cell relationset = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    let relationset' = unsafeManagedPtrCastPtr relationset+    gtk_cell_accessible_parent_update_relationset _obj' cell' relationset'+    touchManagedPtr _obj+    touchManagedPtr cell+    touchManagedPtr relationset+    return ()++
+ GI/Gtk/Interfaces/CellAccessibleParent.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gtk.Interfaces.CellAccessibleParent where++import Prelude ()+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 CellAccessibleParent = CellAccessibleParent (ForeignPtr CellAccessibleParent)+class ForeignPtrNewtype a => CellAccessibleParentK a+instance (ForeignPtrNewtype o, IsDescendantOf CellAccessibleParent o) => CellAccessibleParentK o
+ GI/Gtk/Interfaces/CellEditable.hs view
@@ -0,0 +1,303 @@++{- |+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.Gtk.Interfaces.CellEditable+    ( ++-- * Exported types+    CellEditable(..)                        ,+    noCellEditable                          ,+    CellEditableK                           ,+    toCellEditable                          ,+++ -- * Methods+-- ** cellEditableEditingDone+    cellEditableEditingDone                 ,+++-- ** cellEditableRemoveWidget+    cellEditableRemoveWidget                ,+++-- ** cellEditableStartEditing+    cellEditableStartEditing                ,+++++ -- * Properties+-- ** EditingCanceled+    CellEditableEditingCanceledPropertyInfo ,+    constructCellEditableEditingCanceled    ,+    getCellEditableEditingCanceled          ,+    setCellEditableEditingCanceled          ,+++++ -- * Signals+-- ** EditingDone+    CellEditableEditingDoneCallback         ,+    CellEditableEditingDoneCallbackC        ,+    CellEditableEditingDoneSignalInfo       ,+    afterCellEditableEditingDone            ,+    cellEditableEditingDoneCallbackWrapper  ,+    cellEditableEditingDoneClosure          ,+    mkCellEditableEditingDoneCallback       ,+    noCellEditableEditingDoneCallback       ,+    onCellEditableEditingDone               ,+++-- ** RemoveWidget+    CellEditableRemoveWidgetCallback        ,+    CellEditableRemoveWidgetCallbackC       ,+    CellEditableRemoveWidgetSignalInfo      ,+    afterCellEditableRemoveWidget           ,+    cellEditableRemoveWidgetCallbackWrapper ,+    cellEditableRemoveWidgetClosure         ,+    mkCellEditableRemoveWidgetCallback      ,+    noCellEditableRemoveWidgetCallback      ,+    onCellEditableRemoveWidget              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++-- interface CellEditable ++newtype CellEditable = CellEditable (ForeignPtr CellEditable)+noCellEditable :: Maybe CellEditable+noCellEditable = Nothing++-- signal CellEditable::editing-done+type CellEditableEditingDoneCallback =+    IO ()++noCellEditableEditingDoneCallback :: Maybe CellEditableEditingDoneCallback+noCellEditableEditingDoneCallback = Nothing++type CellEditableEditingDoneCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellEditableEditingDoneCallback :: CellEditableEditingDoneCallbackC -> IO (FunPtr CellEditableEditingDoneCallbackC)++cellEditableEditingDoneClosure :: CellEditableEditingDoneCallback -> IO Closure+cellEditableEditingDoneClosure cb = newCClosure =<< mkCellEditableEditingDoneCallback wrapped+    where wrapped = cellEditableEditingDoneCallbackWrapper cb++cellEditableEditingDoneCallbackWrapper ::+    CellEditableEditingDoneCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+cellEditableEditingDoneCallbackWrapper _cb _ _ = do+    _cb ++onCellEditableEditingDone :: (GObject a, MonadIO m) => a -> CellEditableEditingDoneCallback -> m SignalHandlerId+onCellEditableEditingDone obj cb = liftIO $ connectCellEditableEditingDone obj cb SignalConnectBefore+afterCellEditableEditingDone :: (GObject a, MonadIO m) => a -> CellEditableEditingDoneCallback -> m SignalHandlerId+afterCellEditableEditingDone obj cb = connectCellEditableEditingDone obj cb SignalConnectAfter++connectCellEditableEditingDone :: (GObject a, MonadIO m) =>+                                  a -> CellEditableEditingDoneCallback -> SignalConnectMode -> m SignalHandlerId+connectCellEditableEditingDone obj cb after = liftIO $ do+    cb' <- mkCellEditableEditingDoneCallback (cellEditableEditingDoneCallbackWrapper cb)+    connectSignalFunPtr obj "editing-done" cb' after++-- signal CellEditable::remove-widget+type CellEditableRemoveWidgetCallback =+    IO ()++noCellEditableRemoveWidgetCallback :: Maybe CellEditableRemoveWidgetCallback+noCellEditableRemoveWidgetCallback = Nothing++type CellEditableRemoveWidgetCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellEditableRemoveWidgetCallback :: CellEditableRemoveWidgetCallbackC -> IO (FunPtr CellEditableRemoveWidgetCallbackC)++cellEditableRemoveWidgetClosure :: CellEditableRemoveWidgetCallback -> IO Closure+cellEditableRemoveWidgetClosure cb = newCClosure =<< mkCellEditableRemoveWidgetCallback wrapped+    where wrapped = cellEditableRemoveWidgetCallbackWrapper cb++cellEditableRemoveWidgetCallbackWrapper ::+    CellEditableRemoveWidgetCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+cellEditableRemoveWidgetCallbackWrapper _cb _ _ = do+    _cb ++onCellEditableRemoveWidget :: (GObject a, MonadIO m) => a -> CellEditableRemoveWidgetCallback -> m SignalHandlerId+onCellEditableRemoveWidget obj cb = liftIO $ connectCellEditableRemoveWidget obj cb SignalConnectBefore+afterCellEditableRemoveWidget :: (GObject a, MonadIO m) => a -> CellEditableRemoveWidgetCallback -> m SignalHandlerId+afterCellEditableRemoveWidget obj cb = connectCellEditableRemoveWidget obj cb SignalConnectAfter++connectCellEditableRemoveWidget :: (GObject a, MonadIO m) =>+                                   a -> CellEditableRemoveWidgetCallback -> SignalConnectMode -> m SignalHandlerId+connectCellEditableRemoveWidget obj cb after = liftIO $ do+    cb' <- mkCellEditableRemoveWidgetCallback (cellEditableRemoveWidgetCallbackWrapper cb)+    connectSignalFunPtr obj "remove-widget" cb' after++-- VVV Prop "editing-canceled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellEditableEditingCanceled :: (MonadIO m, CellEditableK o) => o -> m Bool+getCellEditableEditingCanceled obj = liftIO $ getObjectPropertyBool obj "editing-canceled"++setCellEditableEditingCanceled :: (MonadIO m, CellEditableK o) => o -> Bool -> m ()+setCellEditableEditingCanceled obj val = liftIO $ setObjectPropertyBool obj "editing-canceled" val++constructCellEditableEditingCanceled :: Bool -> IO ([Char], GValue)+constructCellEditableEditingCanceled val = constructObjectPropertyBool "editing-canceled" val++data CellEditableEditingCanceledPropertyInfo+instance AttrInfo CellEditableEditingCanceledPropertyInfo where+    type AttrAllowedOps CellEditableEditingCanceledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellEditableEditingCanceledPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellEditableEditingCanceledPropertyInfo = CellEditableK+    type AttrGetType CellEditableEditingCanceledPropertyInfo = Bool+    type AttrLabel CellEditableEditingCanceledPropertyInfo = "CellEditable::editing-canceled"+    attrGet _ = getCellEditableEditingCanceled+    attrSet _ = setCellEditableEditingCanceled+    attrConstruct _ = constructCellEditableEditingCanceled++type instance AttributeList CellEditable = CellEditableAttributeList+type CellEditableAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("editing-canceled", CellEditableEditingCanceledPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data CellEditableEditingDoneSignalInfo+instance SignalInfo CellEditableEditingDoneSignalInfo where+    type HaskellCallbackType CellEditableEditingDoneSignalInfo = CellEditableEditingDoneCallback+    connectSignal _ = connectCellEditableEditingDone++data CellEditableRemoveWidgetSignalInfo+instance SignalInfo CellEditableRemoveWidgetSignalInfo where+    type HaskellCallbackType CellEditableRemoveWidgetSignalInfo = CellEditableRemoveWidgetCallback+    connectSignal _ = connectCellEditableRemoveWidget++type instance SignalList CellEditable = CellEditableSignalList+type CellEditableSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("editing-done", CellEditableEditingDoneSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove-widget", CellEditableRemoveWidgetSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_cell_editable_get_type"+    c_gtk_cell_editable_get_type :: IO GType++type instance ParentTypes CellEditable = CellEditableParentTypes+type CellEditableParentTypes = '[Widget, GObject.Object]++instance GObject CellEditable where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_editable_get_type+    ++class GObject o => CellEditableK o+instance (GObject o, IsDescendantOf CellEditable o) => CellEditableK o++toCellEditable :: CellEditableK o => o -> IO CellEditable+toCellEditable = unsafeCastTo CellEditable++-- method CellEditable::editing_done+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_editable_editing_done" gtk_cell_editable_editing_done :: +    Ptr CellEditable ->                     -- _obj : TInterface "Gtk" "CellEditable"+    IO ()+++cellEditableEditingDone ::+    (MonadIO m, CellEditableK a) =>+    a ->                                    -- _obj+    m ()+cellEditableEditingDone _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_editable_editing_done _obj'+    touchManagedPtr _obj+    return ()++-- method CellEditable::remove_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_editable_remove_widget" gtk_cell_editable_remove_widget :: +    Ptr CellEditable ->                     -- _obj : TInterface "Gtk" "CellEditable"+    IO ()+++cellEditableRemoveWidget ::+    (MonadIO m, CellEditableK a) =>+    a ->                                    -- _obj+    m ()+cellEditableRemoveWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_editable_remove_widget _obj'+    touchManagedPtr _obj+    return ()++-- method CellEditable::start_editing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellEditable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_editable_start_editing" gtk_cell_editable_start_editing :: +    Ptr CellEditable ->                     -- _obj : TInterface "Gtk" "CellEditable"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    IO ()+++cellEditableStartEditing ::+    (MonadIO m, CellEditableK a) =>+    a ->                                    -- _obj+    Maybe (Gdk.Event) ->                    -- event+    m ()+cellEditableStartEditing _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEvent <- case event of+        Nothing -> return nullPtr+        Just jEvent -> do+            let jEvent' = unsafeManagedPtrGetPtr jEvent+            return jEvent'+    gtk_cell_editable_start_editing _obj' maybeEvent+    touchManagedPtr _obj+    whenJust event touchManagedPtr+    return ()++
+ GI/Gtk/Interfaces/CellEditable.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Interfaces.CellEditable where++import Prelude ()+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 CellEditable = CellEditable (ForeignPtr CellEditable)+data CellEditableEditingCanceledPropertyInfo+data CellEditableEditingDoneSignalInfo+data CellEditableRemoveWidgetSignalInfo+instance GObject CellEditable where+class GObject o => CellEditableK o+instance (GObject o, IsDescendantOf CellEditable o) => CellEditableK o
+ GI/Gtk/Interfaces/CellLayout.hs view
@@ -0,0 +1,371 @@++{- |+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.Gtk.Interfaces.CellLayout+    ( ++-- * Exported types+    CellLayout(..)                          ,+    noCellLayout                            ,+    CellLayoutK                             ,+    toCellLayout                            ,+++ -- * Methods+-- ** cellLayoutAddAttribute+    cellLayoutAddAttribute                  ,+++-- ** cellLayoutClear+    cellLayoutClear                         ,+++-- ** cellLayoutClearAttributes+    cellLayoutClearAttributes               ,+++-- ** cellLayoutGetArea+    cellLayoutGetArea                       ,+++-- ** cellLayoutGetCells+    cellLayoutGetCells                      ,+++-- ** cellLayoutPackEnd+    cellLayoutPackEnd                       ,+++-- ** cellLayoutPackStart+    cellLayoutPackStart                     ,+++-- ** cellLayoutReorder+    cellLayoutReorder                       ,+++-- ** cellLayoutSetCellDataFunc+    cellLayoutSetCellDataFunc               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface CellLayout ++newtype CellLayout = CellLayout (ForeignPtr CellLayout)+noCellLayout :: Maybe CellLayout+noCellLayout = Nothing++type instance AttributeList CellLayout = CellLayoutAttributeList+type CellLayoutAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList CellLayout = CellLayoutSignalList+type CellLayoutSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_cell_layout_get_type"+    c_gtk_cell_layout_get_type :: IO GType++type instance ParentTypes CellLayout = CellLayoutParentTypes+type CellLayoutParentTypes = '[GObject.Object]++instance GObject CellLayout where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_cell_layout_get_type+    ++class GObject o => CellLayoutK o+instance (GObject o, IsDescendantOf CellLayout o) => CellLayoutK o++toCellLayout :: CellLayoutK o => o -> IO CellLayout+toCellLayout = unsafeCastTo CellLayout++-- method CellLayout::add_attribute+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", 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 = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", 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 = "column", 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 "gtk_cell_layout_add_attribute" gtk_cell_layout_add_attribute :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    CString ->                              -- attribute : TBasicType TUTF8+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++cellLayoutAddAttribute ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    T.Text ->                               -- attribute+    Int32 ->                                -- column+    m ()+cellLayoutAddAttribute _obj cell attribute column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    attribute' <- textToCString attribute+    gtk_cell_layout_add_attribute _obj' cell' attribute' column+    touchManagedPtr _obj+    touchManagedPtr cell+    freeMem attribute'+    return ()++-- method CellLayout::clear+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_layout_clear" gtk_cell_layout_clear :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    IO ()+++cellLayoutClear ::+    (MonadIO m, CellLayoutK a) =>+    a ->                                    -- _obj+    m ()+cellLayoutClear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_layout_clear _obj'+    touchManagedPtr _obj+    return ()++-- method CellLayout::clear_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_layout_clear_attributes" gtk_cell_layout_clear_attributes :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    IO ()+++cellLayoutClearAttributes ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    m ()+cellLayoutClearAttributes _obj cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    gtk_cell_layout_clear_attributes _obj' cell'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellLayout::get_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellArea"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_layout_get_area" gtk_cell_layout_get_area :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    IO (Ptr CellArea)+++cellLayoutGetArea ::+    (MonadIO m, CellLayoutK a) =>+    a ->                                    -- _obj+    m CellArea+cellLayoutGetArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_layout_get_area _obj'+    checkUnexpectedReturnNULL "gtk_cell_layout_get_area" result+    result' <- (newObject CellArea) result+    touchManagedPtr _obj+    return result'++-- method CellLayout::get_cells+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "CellRenderer")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_layout_get_cells" gtk_cell_layout_get_cells :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    IO (Ptr (GList (Ptr CellRenderer)))+++cellLayoutGetCells ::+    (MonadIO m, CellLayoutK a) =>+    a ->                                    -- _obj+    m [CellRenderer]+cellLayoutGetCells _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_layout_get_cells _obj'+    checkUnexpectedReturnNULL "gtk_cell_layout_get_cells" result+    result' <- unpackGList result+    result'' <- mapM (newObject CellRenderer) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method CellLayout::pack_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", 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 "gtk_cell_layout_pack_end" gtk_cell_layout_pack_end :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- expand : TBasicType TBoolean+    IO ()+++cellLayoutPackEnd ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Bool ->                                 -- expand+    m ()+cellLayoutPackEnd _obj cell expand = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    let expand' = (fromIntegral . fromEnum) expand+    gtk_cell_layout_pack_end _obj' cell' expand'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellLayout::pack_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", 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 "gtk_cell_layout_pack_start" gtk_cell_layout_pack_start :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- expand : TBasicType TBoolean+    IO ()+++cellLayoutPackStart ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Bool ->                                 -- expand+    m ()+cellLayoutPackStart _obj cell expand = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    let expand' = (fromIntegral . fromEnum) expand+    gtk_cell_layout_pack_start _obj' cell' expand'+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellLayout::reorder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", 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 "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", 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 "gtk_cell_layout_reorder" gtk_cell_layout_reorder :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++cellLayoutReorder ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Int32 ->                                -- position+    m ()+cellLayoutReorder _obj cell position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    gtk_cell_layout_reorder _obj' cell' position+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++-- method CellLayout::set_cell_data_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "CellLayoutDataFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing},Arg {argName = "func_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "CellLayoutDataFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_layout_set_cell_data_func" gtk_cell_layout_set_cell_data_func :: +    Ptr CellLayout ->                       -- _obj : TInterface "Gtk" "CellLayout"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    FunPtr CellLayoutDataFuncC ->           -- func : TInterface "Gtk" "CellLayoutDataFunc"+    Ptr () ->                               -- func_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++cellLayoutSetCellDataFunc ::+    (MonadIO m, CellLayoutK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- cell+    Maybe (CellLayoutDataFunc) ->           -- func+    m ()+cellLayoutSetCellDataFunc _obj cell func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cell' = unsafeManagedPtrCastPtr cell+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkCellLayoutDataFunc (cellLayoutDataFuncWrapper Nothing jFunc)+            return jFunc'+    let func_data = castFunPtrToPtr maybeFunc+    let destroy = safeFreeFunPtrPtr+    gtk_cell_layout_set_cell_data_func _obj' cell' maybeFunc func_data destroy+    touchManagedPtr _obj+    touchManagedPtr cell+    return ()++
+ GI/Gtk/Interfaces/CellLayout.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Interfaces.CellLayout where++import Prelude ()+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 CellLayout = CellLayout (ForeignPtr CellLayout)+instance GObject CellLayout where+class GObject o => CellLayoutK o+instance (GObject o, IsDescendantOf CellLayout o) => CellLayoutK o
+ GI/Gtk/Interfaces/ColorChooser.hs view
@@ -0,0 +1,361 @@++{- |+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.Gtk.Interfaces.ColorChooser+    ( ++-- * Exported types+    ColorChooser(..)                        ,+    noColorChooser                          ,+    ColorChooserK                           ,+    toColorChooser                          ,+++ -- * Methods+-- ** colorChooserAddPalette+    colorChooserAddPalette                  ,+++-- ** colorChooserGetRgba+    colorChooserGetRgba                     ,+++-- ** colorChooserGetUseAlpha+    colorChooserGetUseAlpha                 ,+++-- ** colorChooserSetRgba+    colorChooserSetRgba                     ,+++-- ** colorChooserSetUseAlpha+    colorChooserSetUseAlpha                 ,+++++ -- * Properties+-- ** Rgba+    ColorChooserRgbaPropertyInfo            ,+    constructColorChooserRgba               ,+    getColorChooserRgba                     ,+    setColorChooserRgba                     ,+++-- ** UseAlpha+    ColorChooserUseAlphaPropertyInfo        ,+    constructColorChooserUseAlpha           ,+    getColorChooserUseAlpha                 ,+    setColorChooserUseAlpha                 ,+++++ -- * Signals+-- ** ColorActivated+    ColorChooserColorActivatedCallback      ,+    ColorChooserColorActivatedCallbackC     ,+    ColorChooserColorActivatedSignalInfo    ,+    afterColorChooserColorActivated         ,+    colorChooserColorActivatedCallbackWrapper,+    colorChooserColorActivatedClosure       ,+    mkColorChooserColorActivatedCallback    ,+    noColorChooserColorActivatedCallback    ,+    onColorChooserColorActivated            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++-- interface ColorChooser ++newtype ColorChooser = ColorChooser (ForeignPtr ColorChooser)+noColorChooser :: Maybe ColorChooser+noColorChooser = Nothing++-- signal ColorChooser::color-activated+type ColorChooserColorActivatedCallback =+    Gdk.RGBA ->+    IO ()++noColorChooserColorActivatedCallback :: Maybe ColorChooserColorActivatedCallback+noColorChooserColorActivatedCallback = Nothing++type ColorChooserColorActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.RGBA ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkColorChooserColorActivatedCallback :: ColorChooserColorActivatedCallbackC -> IO (FunPtr ColorChooserColorActivatedCallbackC)++colorChooserColorActivatedClosure :: ColorChooserColorActivatedCallback -> IO Closure+colorChooserColorActivatedClosure cb = newCClosure =<< mkColorChooserColorActivatedCallback wrapped+    where wrapped = colorChooserColorActivatedCallbackWrapper cb++colorChooserColorActivatedCallbackWrapper ::+    ColorChooserColorActivatedCallback ->+    Ptr () ->+    Ptr Gdk.RGBA ->+    Ptr () ->+    IO ()+colorChooserColorActivatedCallbackWrapper _cb _ color _ = do+    color' <- (newBoxed Gdk.RGBA) color+    _cb  color'++onColorChooserColorActivated :: (GObject a, MonadIO m) => a -> ColorChooserColorActivatedCallback -> m SignalHandlerId+onColorChooserColorActivated obj cb = liftIO $ connectColorChooserColorActivated obj cb SignalConnectBefore+afterColorChooserColorActivated :: (GObject a, MonadIO m) => a -> ColorChooserColorActivatedCallback -> m SignalHandlerId+afterColorChooserColorActivated obj cb = connectColorChooserColorActivated obj cb SignalConnectAfter++connectColorChooserColorActivated :: (GObject a, MonadIO m) =>+                                     a -> ColorChooserColorActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectColorChooserColorActivated obj cb after = liftIO $ do+    cb' <- mkColorChooserColorActivatedCallback (colorChooserColorActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "color-activated" cb' after++-- VVV Prop "rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getColorChooserRgba :: (MonadIO m, ColorChooserK o) => o -> m Gdk.RGBA+getColorChooserRgba obj = liftIO $ getObjectPropertyBoxed obj "rgba" Gdk.RGBA++setColorChooserRgba :: (MonadIO m, ColorChooserK o) => o -> Gdk.RGBA -> m ()+setColorChooserRgba obj val = liftIO $ setObjectPropertyBoxed obj "rgba" val++constructColorChooserRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructColorChooserRgba val = constructObjectPropertyBoxed "rgba" val++data ColorChooserRgbaPropertyInfo+instance AttrInfo ColorChooserRgbaPropertyInfo where+    type AttrAllowedOps ColorChooserRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorChooserRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint ColorChooserRgbaPropertyInfo = ColorChooserK+    type AttrGetType ColorChooserRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel ColorChooserRgbaPropertyInfo = "ColorChooser::rgba"+    attrGet _ = getColorChooserRgba+    attrSet _ = setColorChooserRgba+    attrConstruct _ = constructColorChooserRgba++-- VVV Prop "use-alpha"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorChooserUseAlpha :: (MonadIO m, ColorChooserK o) => o -> m Bool+getColorChooserUseAlpha obj = liftIO $ getObjectPropertyBool obj "use-alpha"++setColorChooserUseAlpha :: (MonadIO m, ColorChooserK o) => o -> Bool -> m ()+setColorChooserUseAlpha obj val = liftIO $ setObjectPropertyBool obj "use-alpha" val++constructColorChooserUseAlpha :: Bool -> IO ([Char], GValue)+constructColorChooserUseAlpha val = constructObjectPropertyBool "use-alpha" val++data ColorChooserUseAlphaPropertyInfo+instance AttrInfo ColorChooserUseAlphaPropertyInfo where+    type AttrAllowedOps ColorChooserUseAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorChooserUseAlphaPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorChooserUseAlphaPropertyInfo = ColorChooserK+    type AttrGetType ColorChooserUseAlphaPropertyInfo = Bool+    type AttrLabel ColorChooserUseAlphaPropertyInfo = "ColorChooser::use-alpha"+    attrGet _ = getColorChooserUseAlpha+    attrSet _ = setColorChooserUseAlpha+    attrConstruct _ = constructColorChooserUseAlpha++type instance AttributeList ColorChooser = ColorChooserAttributeList+type ColorChooserAttributeList = ('[ '("rgba", ColorChooserRgbaPropertyInfo), '("use-alpha", ColorChooserUseAlphaPropertyInfo)] :: [(Symbol, *)])++data ColorChooserColorActivatedSignalInfo+instance SignalInfo ColorChooserColorActivatedSignalInfo where+    type HaskellCallbackType ColorChooserColorActivatedSignalInfo = ColorChooserColorActivatedCallback+    connectSignal _ = connectColorChooserColorActivated++type instance SignalList ColorChooser = ColorChooserSignalList+type ColorChooserSignalList = ('[ '("color-activated", ColorChooserColorActivatedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_color_chooser_get_type"+    c_gtk_color_chooser_get_type :: IO GType++type instance ParentTypes ColorChooser = ColorChooserParentTypes+type ColorChooserParentTypes = '[GObject.Object]++instance GObject ColorChooser where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_color_chooser_get_type+    ++class GObject o => ColorChooserK o+instance (GObject o, IsDescendantOf ColorChooser o) => ColorChooserK o++toColorChooser :: ColorChooserK o => o -> IO ColorChooser+toColorChooser = unsafeCastTo ColorChooser++-- method ColorChooser::add_palette+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors_per_line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors", argType = TCArray False (-1) 3 (TInterface "Gdk" "RGBA"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors_per_line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors", argType = TCArray False (-1) 3 (TInterface "Gdk" "RGBA"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_add_palette" gtk_color_chooser_add_palette :: +    Ptr ColorChooser ->                     -- _obj : TInterface "Gtk" "ColorChooser"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    Int32 ->                                -- colors_per_line : TBasicType TInt32+    Int32 ->                                -- n_colors : TBasicType TInt32+    Ptr Gdk.RGBA ->                         -- colors : TCArray False (-1) 3 (TInterface "Gdk" "RGBA")+    IO ()+++colorChooserAddPalette ::+    (MonadIO m, ColorChooserK a) =>+    a ->                                    -- _obj+    Orientation ->                          -- orientation+    Int32 ->                                -- colors_per_line+    Maybe ([Gdk.RGBA]) ->                   -- colors+    m ()+colorChooserAddPalette _obj orientation colors_per_line colors = liftIO $ do+    let n_colors = case colors of+            Nothing -> 0+            Just jColors -> fromIntegral $ length jColors+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    maybeColors <- case colors of+        Nothing -> return nullPtr+        Just jColors -> do+            let jColors' = map unsafeManagedPtrGetPtr jColors+            jColors'' <- packBlockArray 32 jColors'+            return jColors''+    gtk_color_chooser_add_palette _obj' orientation' colors_per_line n_colors maybeColors+    touchManagedPtr _obj+    whenJust colors (mapM_ touchManagedPtr)+    freeMem maybeColors+    return ()++-- method ColorChooser::get_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "RGBA", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_get_rgba" gtk_color_chooser_get_rgba :: +    Ptr ColorChooser ->                     -- _obj : TInterface "Gtk" "ColorChooser"+    Ptr Gdk.RGBA ->                         -- color : TInterface "Gdk" "RGBA"+    IO ()+++colorChooserGetRgba ::+    (MonadIO m, ColorChooserK a) =>+    a ->                                    -- _obj+    m (Gdk.RGBA)+colorChooserGetRgba _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA)+    gtk_color_chooser_get_rgba _obj' color+    color' <- (wrapBoxed Gdk.RGBA) color+    touchManagedPtr _obj+    return color'++-- method ColorChooser::get_use_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_get_use_alpha" gtk_color_chooser_get_use_alpha :: +    Ptr ColorChooser ->                     -- _obj : TInterface "Gtk" "ColorChooser"+    IO CInt+++colorChooserGetUseAlpha ::+    (MonadIO m, ColorChooserK a) =>+    a ->                                    -- _obj+    m Bool+colorChooserGetUseAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_chooser_get_use_alpha _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ColorChooser::set_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_set_rgba" gtk_color_chooser_set_rgba :: +    Ptr ColorChooser ->                     -- _obj : TInterface "Gtk" "ColorChooser"+    Ptr Gdk.RGBA ->                         -- color : TInterface "Gdk" "RGBA"+    IO ()+++colorChooserSetRgba ::+    (MonadIO m, ColorChooserK a) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- color+    m ()+colorChooserSetRgba _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let color' = unsafeManagedPtrGetPtr color+    gtk_color_chooser_set_rgba _obj' color'+    touchManagedPtr _obj+    touchManagedPtr color+    return ()++-- method ColorChooser::set_use_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_alpha", 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 "gtk_color_chooser_set_use_alpha" gtk_color_chooser_set_use_alpha :: +    Ptr ColorChooser ->                     -- _obj : TInterface "Gtk" "ColorChooser"+    CInt ->                                 -- use_alpha : TBasicType TBoolean+    IO ()+++colorChooserSetUseAlpha ::+    (MonadIO m, ColorChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_alpha+    m ()+colorChooserSetUseAlpha _obj use_alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_alpha' = (fromIntegral . fromEnum) use_alpha+    gtk_color_chooser_set_use_alpha _obj' use_alpha'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/ColorChooser.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Interfaces.ColorChooser where++import Prelude ()+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 ColorChooser = ColorChooser (ForeignPtr ColorChooser)+data ColorChooserRgbaPropertyInfo+data ColorChooserUseAlphaPropertyInfo+data ColorChooserColorActivatedSignalInfo+instance GObject ColorChooser where+class GObject o => ColorChooserK o+instance (GObject o, IsDescendantOf ColorChooser o) => ColorChooserK o
+ GI/Gtk/Interfaces/Editable.hs view
@@ -0,0 +1,641 @@++{- |+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.Gtk.Interfaces.Editable+    ( ++-- * Exported types+    Editable(..)                            ,+    noEditable                              ,+    EditableK                               ,+++ -- * Methods+-- ** editableCopyClipboard+    editableCopyClipboard                   ,+++-- ** editableCutClipboard+    editableCutClipboard                    ,+++-- ** editableDeleteSelection+    editableDeleteSelection                 ,+++-- ** editableDeleteText+    editableDeleteText                      ,+++-- ** editableGetChars+    editableGetChars                        ,+++-- ** editableGetEditable+    editableGetEditable                     ,+++-- ** editableGetPosition+    editableGetPosition                     ,+++-- ** editableGetSelectionBounds+    editableGetSelectionBounds              ,+++-- ** editableInsertText+    editableInsertText                      ,+++-- ** editablePasteClipboard+    editablePasteClipboard                  ,+++-- ** editableSelectRegion+    editableSelectRegion                    ,+++-- ** editableSetEditable+    editableSetEditable                     ,+++-- ** editableSetPosition+    editableSetPosition                     ,+++++ -- * Signals+-- ** Changed+    EditableChangedCallback                 ,+    EditableChangedCallbackC                ,+    EditableChangedSignalInfo               ,+    afterEditableChanged                    ,+    editableChangedCallbackWrapper          ,+    editableChangedClosure                  ,+    mkEditableChangedCallback               ,+    noEditableChangedCallback               ,+    onEditableChanged                       ,+++-- ** DeleteText+    EditableDeleteTextCallback              ,+    EditableDeleteTextCallbackC             ,+    EditableDeleteTextSignalInfo            ,+    afterEditableDeleteText                 ,+    editableDeleteTextCallbackWrapper       ,+    editableDeleteTextClosure               ,+    mkEditableDeleteTextCallback            ,+    noEditableDeleteTextCallback            ,+    onEditableDeleteText                    ,+++-- ** InsertText+    EditableInsertTextCallback              ,+    EditableInsertTextCallbackC             ,+    EditableInsertTextSignalInfo            ,+    afterEditableInsertText                 ,+    editableInsertTextCallbackWrapper       ,+    editableInsertTextClosure               ,+    mkEditableInsertTextCallback            ,+    noEditableInsertTextCallback            ,+    onEditableInsertText                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++-- interface Editable ++newtype Editable = Editable (ForeignPtr Editable)+noEditable :: Maybe Editable+noEditable = Nothing++-- signal Editable::changed+type EditableChangedCallback =+    IO ()++noEditableChangedCallback :: Maybe EditableChangedCallback+noEditableChangedCallback = Nothing++type EditableChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEditableChangedCallback :: EditableChangedCallbackC -> IO (FunPtr EditableChangedCallbackC)++editableChangedClosure :: EditableChangedCallback -> IO Closure+editableChangedClosure cb = newCClosure =<< mkEditableChangedCallback wrapped+    where wrapped = editableChangedCallbackWrapper cb++editableChangedCallbackWrapper ::+    EditableChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+editableChangedCallbackWrapper _cb _ _ = do+    _cb ++onEditableChanged :: (GObject a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId+onEditableChanged obj cb = liftIO $ connectEditableChanged obj cb SignalConnectBefore+afterEditableChanged :: (GObject a, MonadIO m) => a -> EditableChangedCallback -> m SignalHandlerId+afterEditableChanged obj cb = connectEditableChanged obj cb SignalConnectAfter++connectEditableChanged :: (GObject a, MonadIO m) =>+                          a -> EditableChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectEditableChanged obj cb after = liftIO $ do+    cb' <- mkEditableChangedCallback (editableChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Editable::delete-text+type EditableDeleteTextCallback =+    Int32 ->+    Int32 ->+    IO ()++noEditableDeleteTextCallback :: Maybe EditableDeleteTextCallback+noEditableDeleteTextCallback = Nothing++type EditableDeleteTextCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEditableDeleteTextCallback :: EditableDeleteTextCallbackC -> IO (FunPtr EditableDeleteTextCallbackC)++editableDeleteTextClosure :: EditableDeleteTextCallback -> IO Closure+editableDeleteTextClosure cb = newCClosure =<< mkEditableDeleteTextCallback wrapped+    where wrapped = editableDeleteTextCallbackWrapper cb++editableDeleteTextCallbackWrapper ::+    EditableDeleteTextCallback ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Ptr () ->+    IO ()+editableDeleteTextCallbackWrapper _cb _ start_pos end_pos _ = do+    _cb  start_pos end_pos++onEditableDeleteText :: (GObject a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId+onEditableDeleteText obj cb = liftIO $ connectEditableDeleteText obj cb SignalConnectBefore+afterEditableDeleteText :: (GObject a, MonadIO m) => a -> EditableDeleteTextCallback -> m SignalHandlerId+afterEditableDeleteText obj cb = connectEditableDeleteText obj cb SignalConnectAfter++connectEditableDeleteText :: (GObject a, MonadIO m) =>+                             a -> EditableDeleteTextCallback -> SignalConnectMode -> m SignalHandlerId+connectEditableDeleteText obj cb after = liftIO $ do+    cb' <- mkEditableDeleteTextCallback (editableDeleteTextCallbackWrapper cb)+    connectSignalFunPtr obj "delete-text" cb' after++-- signal Editable::insert-text+type EditableInsertTextCallback =+    T.Text ->+    Int32 ->+    Int32 ->+    IO (Int32)++noEditableInsertTextCallback :: Maybe EditableInsertTextCallback+noEditableInsertTextCallback = Nothing++type EditableInsertTextCallbackC =+    Ptr () ->                               -- object+    CString ->+    Int32 ->+    Ptr Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEditableInsertTextCallback :: EditableInsertTextCallbackC -> IO (FunPtr EditableInsertTextCallbackC)++editableInsertTextClosure :: EditableInsertTextCallback -> IO Closure+editableInsertTextClosure cb = newCClosure =<< mkEditableInsertTextCallback wrapped+    where wrapped = editableInsertTextCallbackWrapper cb++editableInsertTextCallbackWrapper ::+    EditableInsertTextCallback ->+    Ptr () ->+    CString ->+    Int32 ->+    Ptr Int32 ->+    Ptr () ->+    IO ()+editableInsertTextCallbackWrapper _cb _ new_text new_text_length position _ = do+    new_text' <- cstringToText new_text+    position' <- peek position+    outposition <- _cb  new_text' new_text_length position'+    poke position outposition++onEditableInsertText :: (GObject a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId+onEditableInsertText obj cb = liftIO $ connectEditableInsertText obj cb SignalConnectBefore+afterEditableInsertText :: (GObject a, MonadIO m) => a -> EditableInsertTextCallback -> m SignalHandlerId+afterEditableInsertText obj cb = connectEditableInsertText obj cb SignalConnectAfter++connectEditableInsertText :: (GObject a, MonadIO m) =>+                             a -> EditableInsertTextCallback -> SignalConnectMode -> m SignalHandlerId+connectEditableInsertText obj cb after = liftIO $ do+    cb' <- mkEditableInsertTextCallback (editableInsertTextCallbackWrapper cb)+    connectSignalFunPtr obj "insert-text" cb' after++type instance AttributeList Editable = EditableAttributeList+type EditableAttributeList = ('[ ] :: [(Symbol, *)])++data EditableChangedSignalInfo+instance SignalInfo EditableChangedSignalInfo where+    type HaskellCallbackType EditableChangedSignalInfo = EditableChangedCallback+    connectSignal _ = connectEditableChanged++data EditableDeleteTextSignalInfo+instance SignalInfo EditableDeleteTextSignalInfo where+    type HaskellCallbackType EditableDeleteTextSignalInfo = EditableDeleteTextCallback+    connectSignal _ = connectEditableDeleteText++data EditableInsertTextSignalInfo+instance SignalInfo EditableInsertTextSignalInfo where+    type HaskellCallbackType EditableInsertTextSignalInfo = EditableInsertTextCallback+    connectSignal _ = connectEditableInsertText++type instance SignalList Editable = EditableSignalList+type EditableSignalList = ('[ '("changed", EditableChangedSignalInfo), '("delete-text", EditableDeleteTextSignalInfo), '("insert-text", EditableInsertTextSignalInfo)] :: [(Symbol, *)])++class ForeignPtrNewtype a => EditableK a+instance (ForeignPtrNewtype o, IsDescendantOf Editable o) => EditableK o+type instance ParentTypes Editable = EditableParentTypes+type EditableParentTypes = '[]++-- method Editable::copy_clipboard+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_copy_clipboard" gtk_editable_copy_clipboard :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO ()+++editableCopyClipboard ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m ()+editableCopyClipboard _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_copy_clipboard _obj'+    touchManagedPtr _obj+    return ()++-- method Editable::cut_clipboard+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_cut_clipboard" gtk_editable_cut_clipboard :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO ()+++editableCutClipboard ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m ()+editableCutClipboard _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_cut_clipboard _obj'+    touchManagedPtr _obj+    return ()++-- method Editable::delete_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_delete_selection" gtk_editable_delete_selection :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO ()+++editableDeleteSelection ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m ()+editableDeleteSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_delete_selection _obj'+    touchManagedPtr _obj+    return ()++-- method Editable::delete_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", 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 "gtk_editable_delete_text" gtk_editable_delete_text :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    Int32 ->                                -- start_pos : TBasicType TInt32+    Int32 ->                                -- end_pos : TBasicType TInt32+    IO ()+++editableDeleteText ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- start_pos+    Int32 ->                                -- end_pos+    m ()+editableDeleteText _obj start_pos end_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_delete_text _obj' start_pos end_pos+    touchManagedPtr _obj+    return ()++-- method Editable::get_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_get_chars" gtk_editable_get_chars :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    Int32 ->                                -- start_pos : TBasicType TInt32+    Int32 ->                                -- end_pos : TBasicType TInt32+    IO CString+++editableGetChars ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- start_pos+    Int32 ->                                -- end_pos+    m T.Text+editableGetChars _obj start_pos end_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_editable_get_chars _obj' start_pos end_pos+    checkUnexpectedReturnNULL "gtk_editable_get_chars" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Editable::get_editable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_get_editable" gtk_editable_get_editable :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO CInt+++editableGetEditable ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m Bool+editableGetEditable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_editable_get_editable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Editable::get_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_get_position" gtk_editable_get_position :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO Int32+++editableGetPosition ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m Int32+editableGetPosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_editable_get_position _obj'+    touchManagedPtr _obj+    return result++-- method Editable::get_selection_bounds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "end_pos", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_get_selection_bounds" gtk_editable_get_selection_bounds :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    Ptr Int32 ->                            -- start_pos : TBasicType TInt32+    Ptr Int32 ->                            -- end_pos : TBasicType TInt32+    IO CInt+++editableGetSelectionBounds ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m (Bool,Int32,Int32)+editableGetSelectionBounds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    start_pos <- allocMem :: IO (Ptr Int32)+    end_pos <- allocMem :: IO (Ptr Int32)+    result <- gtk_editable_get_selection_bounds _obj' start_pos end_pos+    let result' = (/= 0) result+    start_pos' <- peek start_pos+    end_pos' <- peek end_pos+    touchManagedPtr _obj+    freeMem start_pos+    freeMem end_pos+    return (result', start_pos', end_pos')++-- method Editable::insert_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_text_length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_text_length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_insert_text" gtk_editable_insert_text :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    CString ->                              -- new_text : TBasicType TUTF8+    Int32 ->                                -- new_text_length : TBasicType TInt32+    Ptr Int32 ->                            -- position : TBasicType TInt32+    IO ()+++editableInsertText ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- new_text+    Int32 ->                                -- new_text_length+    Int32 ->                                -- position+    m (Int32)+editableInsertText _obj new_text new_text_length position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    new_text' <- textToCString new_text+    position' <- allocMem :: IO (Ptr Int32)+    poke position' position+    gtk_editable_insert_text _obj' new_text' new_text_length position'+    position'' <- peek position'+    touchManagedPtr _obj+    freeMem new_text'+    freeMem position'+    return position''++-- method Editable::paste_clipboard+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_editable_paste_clipboard" gtk_editable_paste_clipboard :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    IO ()+++editablePasteClipboard ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    m ()+editablePasteClipboard _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_paste_clipboard _obj'+    touchManagedPtr _obj+    return ()++-- method Editable::select_region+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_pos", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_pos", 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 "gtk_editable_select_region" gtk_editable_select_region :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    Int32 ->                                -- start_pos : TBasicType TInt32+    Int32 ->                                -- end_pos : TBasicType TInt32+    IO ()+++editableSelectRegion ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- start_pos+    Int32 ->                                -- end_pos+    m ()+editableSelectRegion _obj start_pos end_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_select_region _obj' start_pos end_pos+    touchManagedPtr _obj+    return ()++-- method Editable::set_editable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_editable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_editable", 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 "gtk_editable_set_editable" gtk_editable_set_editable :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    CInt ->                                 -- is_editable : TBasicType TBoolean+    IO ()+++editableSetEditable ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_editable+    m ()+editableSetEditable _obj is_editable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_editable' = (fromIntegral . fromEnum) is_editable+    gtk_editable_set_editable _obj' is_editable'+    touchManagedPtr _obj+    return ()++-- method Editable::set_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Editable", 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 "Gtk" "Editable", 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 "gtk_editable_set_position" gtk_editable_set_position :: +    Ptr Editable ->                         -- _obj : TInterface "Gtk" "Editable"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++editableSetPosition ::+    (MonadIO m, EditableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+editableSetPosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_editable_set_position _obj' position+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/Editable.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Interfaces.Editable where++import Prelude ()+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 Editable = Editable (ForeignPtr Editable)+data EditableChangedSignalInfo+data EditableDeleteTextSignalInfo+data EditableInsertTextSignalInfo+class ForeignPtrNewtype a => EditableK a+instance (ForeignPtrNewtype o, IsDescendantOf Editable o) => EditableK o
+ GI/Gtk/Interfaces/FileChooser.hs view
@@ -0,0 +1,2562 @@++{- |+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.Gtk.Interfaces.FileChooser+    ( ++-- * Exported types+    FileChooser(..)                         ,+    noFileChooser                           ,+    FileChooserK                            ,+    toFileChooser                           ,+++ -- * Methods+-- ** fileChooserAddFilter+    fileChooserAddFilter                    ,+++-- ** fileChooserAddShortcutFolder+    fileChooserAddShortcutFolder            ,+++-- ** fileChooserAddShortcutFolderUri+    fileChooserAddShortcutFolderUri         ,+++-- ** fileChooserGetAction+    fileChooserGetAction                    ,+++-- ** fileChooserGetCreateFolders+    fileChooserGetCreateFolders             ,+++-- ** fileChooserGetCurrentFolder+    fileChooserGetCurrentFolder             ,+++-- ** fileChooserGetCurrentFolderFile+    fileChooserGetCurrentFolderFile         ,+++-- ** fileChooserGetCurrentFolderUri+    fileChooserGetCurrentFolderUri          ,+++-- ** fileChooserGetCurrentName+    fileChooserGetCurrentName               ,+++-- ** fileChooserGetDoOverwriteConfirmation+    fileChooserGetDoOverwriteConfirmation   ,+++-- ** fileChooserGetExtraWidget+    fileChooserGetExtraWidget               ,+++-- ** fileChooserGetFile+    fileChooserGetFile                      ,+++-- ** fileChooserGetFilename+    fileChooserGetFilename                  ,+++-- ** fileChooserGetFilenames+    fileChooserGetFilenames                 ,+++-- ** fileChooserGetFiles+    fileChooserGetFiles                     ,+++-- ** fileChooserGetFilter+    fileChooserGetFilter                    ,+++-- ** fileChooserGetLocalOnly+    fileChooserGetLocalOnly                 ,+++-- ** fileChooserGetPreviewFile+    fileChooserGetPreviewFile               ,+++-- ** fileChooserGetPreviewFilename+    fileChooserGetPreviewFilename           ,+++-- ** fileChooserGetPreviewUri+    fileChooserGetPreviewUri                ,+++-- ** fileChooserGetPreviewWidget+    fileChooserGetPreviewWidget             ,+++-- ** fileChooserGetPreviewWidgetActive+    fileChooserGetPreviewWidgetActive       ,+++-- ** fileChooserGetSelectMultiple+    fileChooserGetSelectMultiple            ,+++-- ** fileChooserGetShowHidden+    fileChooserGetShowHidden                ,+++-- ** fileChooserGetUri+    fileChooserGetUri                       ,+++-- ** fileChooserGetUris+    fileChooserGetUris                      ,+++-- ** fileChooserGetUsePreviewLabel+    fileChooserGetUsePreviewLabel           ,+++-- ** fileChooserListFilters+    fileChooserListFilters                  ,+++-- ** fileChooserListShortcutFolderUris+    fileChooserListShortcutFolderUris       ,+++-- ** fileChooserListShortcutFolders+    fileChooserListShortcutFolders          ,+++-- ** fileChooserRemoveFilter+    fileChooserRemoveFilter                 ,+++-- ** fileChooserRemoveShortcutFolder+    fileChooserRemoveShortcutFolder         ,+++-- ** fileChooserRemoveShortcutFolderUri+    fileChooserRemoveShortcutFolderUri      ,+++-- ** fileChooserSelectAll+    fileChooserSelectAll                    ,+++-- ** fileChooserSelectFile+    fileChooserSelectFile                   ,+++-- ** fileChooserSelectFilename+    fileChooserSelectFilename               ,+++-- ** fileChooserSelectUri+    fileChooserSelectUri                    ,+++-- ** fileChooserSetAction+    fileChooserSetAction                    ,+++-- ** fileChooserSetCreateFolders+    fileChooserSetCreateFolders             ,+++-- ** fileChooserSetCurrentFolder+    fileChooserSetCurrentFolder             ,+++-- ** fileChooserSetCurrentFolderFile+    fileChooserSetCurrentFolderFile         ,+++-- ** fileChooserSetCurrentFolderUri+    fileChooserSetCurrentFolderUri          ,+++-- ** fileChooserSetCurrentName+    fileChooserSetCurrentName               ,+++-- ** fileChooserSetDoOverwriteConfirmation+    fileChooserSetDoOverwriteConfirmation   ,+++-- ** fileChooserSetExtraWidget+    fileChooserSetExtraWidget               ,+++-- ** fileChooserSetFile+    fileChooserSetFile                      ,+++-- ** fileChooserSetFilename+    fileChooserSetFilename                  ,+++-- ** fileChooserSetFilter+    fileChooserSetFilter                    ,+++-- ** fileChooserSetLocalOnly+    fileChooserSetLocalOnly                 ,+++-- ** fileChooserSetPreviewWidget+    fileChooserSetPreviewWidget             ,+++-- ** fileChooserSetPreviewWidgetActive+    fileChooserSetPreviewWidgetActive       ,+++-- ** fileChooserSetSelectMultiple+    fileChooserSetSelectMultiple            ,+++-- ** fileChooserSetShowHidden+    fileChooserSetShowHidden                ,+++-- ** fileChooserSetUri+    fileChooserSetUri                       ,+++-- ** fileChooserSetUsePreviewLabel+    fileChooserSetUsePreviewLabel           ,+++-- ** fileChooserUnselectAll+    fileChooserUnselectAll                  ,+++-- ** fileChooserUnselectFile+    fileChooserUnselectFile                 ,+++-- ** fileChooserUnselectFilename+    fileChooserUnselectFilename             ,+++-- ** fileChooserUnselectUri+    fileChooserUnselectUri                  ,+++++ -- * Properties+-- ** Action+    FileChooserActionPropertyInfo           ,+    constructFileChooserAction              ,+    getFileChooserAction                    ,+    setFileChooserAction                    ,+++-- ** CreateFolders+    FileChooserCreateFoldersPropertyInfo    ,+    constructFileChooserCreateFolders       ,+    getFileChooserCreateFolders             ,+    setFileChooserCreateFolders             ,+++-- ** DoOverwriteConfirmation+    FileChooserDoOverwriteConfirmationPropertyInfo,+    constructFileChooserDoOverwriteConfirmation,+    getFileChooserDoOverwriteConfirmation   ,+    setFileChooserDoOverwriteConfirmation   ,+++-- ** ExtraWidget+    FileChooserExtraWidgetPropertyInfo      ,+    constructFileChooserExtraWidget         ,+    getFileChooserExtraWidget               ,+    setFileChooserExtraWidget               ,+++-- ** Filter+    FileChooserFilterPropertyInfo           ,+    constructFileChooserFilter              ,+    getFileChooserFilter                    ,+    setFileChooserFilter                    ,+++-- ** LocalOnly+    FileChooserLocalOnlyPropertyInfo        ,+    constructFileChooserLocalOnly           ,+    getFileChooserLocalOnly                 ,+    setFileChooserLocalOnly                 ,+++-- ** PreviewWidget+    FileChooserPreviewWidgetPropertyInfo    ,+    constructFileChooserPreviewWidget       ,+    getFileChooserPreviewWidget             ,+    setFileChooserPreviewWidget             ,+++-- ** PreviewWidgetActive+    FileChooserPreviewWidgetActivePropertyInfo,+    constructFileChooserPreviewWidgetActive ,+    getFileChooserPreviewWidgetActive       ,+    setFileChooserPreviewWidgetActive       ,+++-- ** SelectMultiple+    FileChooserSelectMultiplePropertyInfo   ,+    constructFileChooserSelectMultiple      ,+    getFileChooserSelectMultiple            ,+    setFileChooserSelectMultiple            ,+++-- ** ShowHidden+    FileChooserShowHiddenPropertyInfo       ,+    constructFileChooserShowHidden          ,+    getFileChooserShowHidden                ,+    setFileChooserShowHidden                ,+++-- ** UsePreviewLabel+    FileChooserUsePreviewLabelPropertyInfo  ,+    constructFileChooserUsePreviewLabel     ,+    getFileChooserUsePreviewLabel           ,+    setFileChooserUsePreviewLabel           ,+++++ -- * Signals+-- ** ConfirmOverwrite+    FileChooserConfirmOverwriteCallback     ,+    FileChooserConfirmOverwriteCallbackC    ,+    FileChooserConfirmOverwriteSignalInfo   ,+    afterFileChooserConfirmOverwrite        ,+    fileChooserConfirmOverwriteCallbackWrapper,+    fileChooserConfirmOverwriteClosure      ,+    mkFileChooserConfirmOverwriteCallback   ,+    noFileChooserConfirmOverwriteCallback   ,+    onFileChooserConfirmOverwrite           ,+++-- ** CurrentFolderChanged+    FileChooserCurrentFolderChangedCallback ,+    FileChooserCurrentFolderChangedCallbackC,+    FileChooserCurrentFolderChangedSignalInfo,+    afterFileChooserCurrentFolderChanged    ,+    fileChooserCurrentFolderChangedCallbackWrapper,+    fileChooserCurrentFolderChangedClosure  ,+    mkFileChooserCurrentFolderChangedCallback,+    noFileChooserCurrentFolderChangedCallback,+    onFileChooserCurrentFolderChanged       ,+++-- ** FileActivated+    FileChooserFileActivatedCallback        ,+    FileChooserFileActivatedCallbackC       ,+    FileChooserFileActivatedSignalInfo      ,+    afterFileChooserFileActivated           ,+    fileChooserFileActivatedCallbackWrapper ,+    fileChooserFileActivatedClosure         ,+    mkFileChooserFileActivatedCallback      ,+    noFileChooserFileActivatedCallback      ,+    onFileChooserFileActivated              ,+++-- ** SelectionChanged+    FileChooserSelectionChangedCallback     ,+    FileChooserSelectionChangedCallbackC    ,+    FileChooserSelectionChangedSignalInfo   ,+    afterFileChooserSelectionChanged        ,+    fileChooserSelectionChangedCallbackWrapper,+    fileChooserSelectionChangedClosure      ,+    mkFileChooserSelectionChangedCallback   ,+    noFileChooserSelectionChangedCallback   ,+    onFileChooserSelectionChanged           ,+++-- ** UpdatePreview+    FileChooserUpdatePreviewCallback        ,+    FileChooserUpdatePreviewCallbackC       ,+    FileChooserUpdatePreviewSignalInfo      ,+    afterFileChooserUpdatePreview           ,+    fileChooserUpdatePreviewCallbackWrapper ,+    fileChooserUpdatePreviewClosure         ,+    mkFileChooserUpdatePreviewCallback      ,+    noFileChooserUpdatePreviewCallback      ,+    onFileChooserUpdatePreview              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++-- interface FileChooser ++newtype FileChooser = FileChooser (ForeignPtr FileChooser)+noFileChooser :: Maybe FileChooser+noFileChooser = Nothing++-- signal FileChooser::confirm-overwrite+type FileChooserConfirmOverwriteCallback =+    IO FileChooserConfirmation++noFileChooserConfirmOverwriteCallback :: Maybe FileChooserConfirmOverwriteCallback+noFileChooserConfirmOverwriteCallback = Nothing++type FileChooserConfirmOverwriteCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CUInt++foreign import ccall "wrapper"+    mkFileChooserConfirmOverwriteCallback :: FileChooserConfirmOverwriteCallbackC -> IO (FunPtr FileChooserConfirmOverwriteCallbackC)++fileChooserConfirmOverwriteClosure :: FileChooserConfirmOverwriteCallback -> IO Closure+fileChooserConfirmOverwriteClosure cb = newCClosure =<< mkFileChooserConfirmOverwriteCallback wrapped+    where wrapped = fileChooserConfirmOverwriteCallbackWrapper cb++fileChooserConfirmOverwriteCallbackWrapper ::+    FileChooserConfirmOverwriteCallback ->+    Ptr () ->+    Ptr () ->+    IO CUInt+fileChooserConfirmOverwriteCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onFileChooserConfirmOverwrite :: (GObject a, MonadIO m) => a -> FileChooserConfirmOverwriteCallback -> m SignalHandlerId+onFileChooserConfirmOverwrite obj cb = liftIO $ connectFileChooserConfirmOverwrite obj cb SignalConnectBefore+afterFileChooserConfirmOverwrite :: (GObject a, MonadIO m) => a -> FileChooserConfirmOverwriteCallback -> m SignalHandlerId+afterFileChooserConfirmOverwrite obj cb = connectFileChooserConfirmOverwrite obj cb SignalConnectAfter++connectFileChooserConfirmOverwrite :: (GObject a, MonadIO m) =>+                                      a -> FileChooserConfirmOverwriteCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserConfirmOverwrite obj cb after = liftIO $ do+    cb' <- mkFileChooserConfirmOverwriteCallback (fileChooserConfirmOverwriteCallbackWrapper cb)+    connectSignalFunPtr obj "confirm-overwrite" cb' after++-- signal FileChooser::current-folder-changed+type FileChooserCurrentFolderChangedCallback =+    IO ()++noFileChooserCurrentFolderChangedCallback :: Maybe FileChooserCurrentFolderChangedCallback+noFileChooserCurrentFolderChangedCallback = Nothing++type FileChooserCurrentFolderChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserCurrentFolderChangedCallback :: FileChooserCurrentFolderChangedCallbackC -> IO (FunPtr FileChooserCurrentFolderChangedCallbackC)++fileChooserCurrentFolderChangedClosure :: FileChooserCurrentFolderChangedCallback -> IO Closure+fileChooserCurrentFolderChangedClosure cb = newCClosure =<< mkFileChooserCurrentFolderChangedCallback wrapped+    where wrapped = fileChooserCurrentFolderChangedCallbackWrapper cb++fileChooserCurrentFolderChangedCallbackWrapper ::+    FileChooserCurrentFolderChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserCurrentFolderChangedCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserCurrentFolderChanged :: (GObject a, MonadIO m) => a -> FileChooserCurrentFolderChangedCallback -> m SignalHandlerId+onFileChooserCurrentFolderChanged obj cb = liftIO $ connectFileChooserCurrentFolderChanged obj cb SignalConnectBefore+afterFileChooserCurrentFolderChanged :: (GObject a, MonadIO m) => a -> FileChooserCurrentFolderChangedCallback -> m SignalHandlerId+afterFileChooserCurrentFolderChanged obj cb = connectFileChooserCurrentFolderChanged obj cb SignalConnectAfter++connectFileChooserCurrentFolderChanged :: (GObject a, MonadIO m) =>+                                          a -> FileChooserCurrentFolderChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserCurrentFolderChanged obj cb after = liftIO $ do+    cb' <- mkFileChooserCurrentFolderChangedCallback (fileChooserCurrentFolderChangedCallbackWrapper cb)+    connectSignalFunPtr obj "current-folder-changed" cb' after++-- signal FileChooser::file-activated+type FileChooserFileActivatedCallback =+    IO ()++noFileChooserFileActivatedCallback :: Maybe FileChooserFileActivatedCallback+noFileChooserFileActivatedCallback = Nothing++type FileChooserFileActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserFileActivatedCallback :: FileChooserFileActivatedCallbackC -> IO (FunPtr FileChooserFileActivatedCallbackC)++fileChooserFileActivatedClosure :: FileChooserFileActivatedCallback -> IO Closure+fileChooserFileActivatedClosure cb = newCClosure =<< mkFileChooserFileActivatedCallback wrapped+    where wrapped = fileChooserFileActivatedCallbackWrapper cb++fileChooserFileActivatedCallbackWrapper ::+    FileChooserFileActivatedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserFileActivatedCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserFileActivated :: (GObject a, MonadIO m) => a -> FileChooserFileActivatedCallback -> m SignalHandlerId+onFileChooserFileActivated obj cb = liftIO $ connectFileChooserFileActivated obj cb SignalConnectBefore+afterFileChooserFileActivated :: (GObject a, MonadIO m) => a -> FileChooserFileActivatedCallback -> m SignalHandlerId+afterFileChooserFileActivated obj cb = connectFileChooserFileActivated obj cb SignalConnectAfter++connectFileChooserFileActivated :: (GObject a, MonadIO m) =>+                                   a -> FileChooserFileActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserFileActivated obj cb after = liftIO $ do+    cb' <- mkFileChooserFileActivatedCallback (fileChooserFileActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "file-activated" cb' after++-- signal FileChooser::selection-changed+type FileChooserSelectionChangedCallback =+    IO ()++noFileChooserSelectionChangedCallback :: Maybe FileChooserSelectionChangedCallback+noFileChooserSelectionChangedCallback = Nothing++type FileChooserSelectionChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserSelectionChangedCallback :: FileChooserSelectionChangedCallbackC -> IO (FunPtr FileChooserSelectionChangedCallbackC)++fileChooserSelectionChangedClosure :: FileChooserSelectionChangedCallback -> IO Closure+fileChooserSelectionChangedClosure cb = newCClosure =<< mkFileChooserSelectionChangedCallback wrapped+    where wrapped = fileChooserSelectionChangedCallbackWrapper cb++fileChooserSelectionChangedCallbackWrapper ::+    FileChooserSelectionChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserSelectionChangedCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserSelectionChanged :: (GObject a, MonadIO m) => a -> FileChooserSelectionChangedCallback -> m SignalHandlerId+onFileChooserSelectionChanged obj cb = liftIO $ connectFileChooserSelectionChanged obj cb SignalConnectBefore+afterFileChooserSelectionChanged :: (GObject a, MonadIO m) => a -> FileChooserSelectionChangedCallback -> m SignalHandlerId+afterFileChooserSelectionChanged obj cb = connectFileChooserSelectionChanged obj cb SignalConnectAfter++connectFileChooserSelectionChanged :: (GObject a, MonadIO m) =>+                                      a -> FileChooserSelectionChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserSelectionChanged obj cb after = liftIO $ do+    cb' <- mkFileChooserSelectionChangedCallback (fileChooserSelectionChangedCallbackWrapper cb)+    connectSignalFunPtr obj "selection-changed" cb' after++-- signal FileChooser::update-preview+type FileChooserUpdatePreviewCallback =+    IO ()++noFileChooserUpdatePreviewCallback :: Maybe FileChooserUpdatePreviewCallback+noFileChooserUpdatePreviewCallback = Nothing++type FileChooserUpdatePreviewCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserUpdatePreviewCallback :: FileChooserUpdatePreviewCallbackC -> IO (FunPtr FileChooserUpdatePreviewCallbackC)++fileChooserUpdatePreviewClosure :: FileChooserUpdatePreviewCallback -> IO Closure+fileChooserUpdatePreviewClosure cb = newCClosure =<< mkFileChooserUpdatePreviewCallback wrapped+    where wrapped = fileChooserUpdatePreviewCallbackWrapper cb++fileChooserUpdatePreviewCallbackWrapper ::+    FileChooserUpdatePreviewCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserUpdatePreviewCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserUpdatePreview :: (GObject a, MonadIO m) => a -> FileChooserUpdatePreviewCallback -> m SignalHandlerId+onFileChooserUpdatePreview obj cb = liftIO $ connectFileChooserUpdatePreview obj cb SignalConnectBefore+afterFileChooserUpdatePreview :: (GObject a, MonadIO m) => a -> FileChooserUpdatePreviewCallback -> m SignalHandlerId+afterFileChooserUpdatePreview obj cb = connectFileChooserUpdatePreview obj cb SignalConnectAfter++connectFileChooserUpdatePreview :: (GObject a, MonadIO m) =>+                                   a -> FileChooserUpdatePreviewCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserUpdatePreview obj cb after = liftIO $ do+    cb' <- mkFileChooserUpdatePreviewCallback (fileChooserUpdatePreviewCallbackWrapper cb)+    connectSignalFunPtr obj "update-preview" cb' after++-- VVV Prop "action"+   -- Type: TInterface "Gtk" "FileChooserAction"+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserAction :: (MonadIO m, FileChooserK o) => o -> m FileChooserAction+getFileChooserAction obj = liftIO $ getObjectPropertyEnum obj "action"++setFileChooserAction :: (MonadIO m, FileChooserK o) => o -> FileChooserAction -> m ()+setFileChooserAction obj val = liftIO $ setObjectPropertyEnum obj "action" val++constructFileChooserAction :: FileChooserAction -> IO ([Char], GValue)+constructFileChooserAction val = constructObjectPropertyEnum "action" val++data FileChooserActionPropertyInfo+instance AttrInfo FileChooserActionPropertyInfo where+    type AttrAllowedOps FileChooserActionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserActionPropertyInfo = (~) FileChooserAction+    type AttrBaseTypeConstraint FileChooserActionPropertyInfo = FileChooserK+    type AttrGetType FileChooserActionPropertyInfo = FileChooserAction+    type AttrLabel FileChooserActionPropertyInfo = "FileChooser::action"+    attrGet _ = getFileChooserAction+    attrSet _ = setFileChooserAction+    attrConstruct _ = constructFileChooserAction++-- VVV Prop "create-folders"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserCreateFolders :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserCreateFolders obj = liftIO $ getObjectPropertyBool obj "create-folders"++setFileChooserCreateFolders :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserCreateFolders obj val = liftIO $ setObjectPropertyBool obj "create-folders" val++constructFileChooserCreateFolders :: Bool -> IO ([Char], GValue)+constructFileChooserCreateFolders val = constructObjectPropertyBool "create-folders" val++data FileChooserCreateFoldersPropertyInfo+instance AttrInfo FileChooserCreateFoldersPropertyInfo where+    type AttrAllowedOps FileChooserCreateFoldersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserCreateFoldersPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserCreateFoldersPropertyInfo = FileChooserK+    type AttrGetType FileChooserCreateFoldersPropertyInfo = Bool+    type AttrLabel FileChooserCreateFoldersPropertyInfo = "FileChooser::create-folders"+    attrGet _ = getFileChooserCreateFolders+    attrSet _ = setFileChooserCreateFolders+    attrConstruct _ = constructFileChooserCreateFolders++-- VVV Prop "do-overwrite-confirmation"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserDoOverwriteConfirmation :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserDoOverwriteConfirmation obj = liftIO $ getObjectPropertyBool obj "do-overwrite-confirmation"++setFileChooserDoOverwriteConfirmation :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserDoOverwriteConfirmation obj val = liftIO $ setObjectPropertyBool obj "do-overwrite-confirmation" val++constructFileChooserDoOverwriteConfirmation :: Bool -> IO ([Char], GValue)+constructFileChooserDoOverwriteConfirmation val = constructObjectPropertyBool "do-overwrite-confirmation" val++data FileChooserDoOverwriteConfirmationPropertyInfo+instance AttrInfo FileChooserDoOverwriteConfirmationPropertyInfo where+    type AttrAllowedOps FileChooserDoOverwriteConfirmationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserDoOverwriteConfirmationPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserDoOverwriteConfirmationPropertyInfo = FileChooserK+    type AttrGetType FileChooserDoOverwriteConfirmationPropertyInfo = Bool+    type AttrLabel FileChooserDoOverwriteConfirmationPropertyInfo = "FileChooser::do-overwrite-confirmation"+    attrGet _ = getFileChooserDoOverwriteConfirmation+    attrSet _ = setFileChooserDoOverwriteConfirmation+    attrConstruct _ = constructFileChooserDoOverwriteConfirmation++-- VVV Prop "extra-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserExtraWidget :: (MonadIO m, FileChooserK o) => o -> m Widget+getFileChooserExtraWidget obj = liftIO $ getObjectPropertyObject obj "extra-widget" Widget++setFileChooserExtraWidget :: (MonadIO m, FileChooserK o, WidgetK a) => o -> a -> m ()+setFileChooserExtraWidget obj val = liftIO $ setObjectPropertyObject obj "extra-widget" val++constructFileChooserExtraWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructFileChooserExtraWidget val = constructObjectPropertyObject "extra-widget" val++data FileChooserExtraWidgetPropertyInfo+instance AttrInfo FileChooserExtraWidgetPropertyInfo where+    type AttrAllowedOps FileChooserExtraWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserExtraWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint FileChooserExtraWidgetPropertyInfo = FileChooserK+    type AttrGetType FileChooserExtraWidgetPropertyInfo = Widget+    type AttrLabel FileChooserExtraWidgetPropertyInfo = "FileChooser::extra-widget"+    attrGet _ = getFileChooserExtraWidget+    attrSet _ = setFileChooserExtraWidget+    attrConstruct _ = constructFileChooserExtraWidget++-- VVV Prop "filter"+   -- Type: TInterface "Gtk" "FileFilter"+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserFilter :: (MonadIO m, FileChooserK o) => o -> m FileFilter+getFileChooserFilter obj = liftIO $ getObjectPropertyObject obj "filter" FileFilter++setFileChooserFilter :: (MonadIO m, FileChooserK o, FileFilterK a) => o -> a -> m ()+setFileChooserFilter obj val = liftIO $ setObjectPropertyObject obj "filter" val++constructFileChooserFilter :: (FileFilterK a) => a -> IO ([Char], GValue)+constructFileChooserFilter val = constructObjectPropertyObject "filter" val++data FileChooserFilterPropertyInfo+instance AttrInfo FileChooserFilterPropertyInfo where+    type AttrAllowedOps FileChooserFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserFilterPropertyInfo = FileFilterK+    type AttrBaseTypeConstraint FileChooserFilterPropertyInfo = FileChooserK+    type AttrGetType FileChooserFilterPropertyInfo = FileFilter+    type AttrLabel FileChooserFilterPropertyInfo = "FileChooser::filter"+    attrGet _ = getFileChooserFilter+    attrSet _ = setFileChooserFilter+    attrConstruct _ = constructFileChooserFilter++-- VVV Prop "local-only"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserLocalOnly :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserLocalOnly obj = liftIO $ getObjectPropertyBool obj "local-only"++setFileChooserLocalOnly :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserLocalOnly obj val = liftIO $ setObjectPropertyBool obj "local-only" val++constructFileChooserLocalOnly :: Bool -> IO ([Char], GValue)+constructFileChooserLocalOnly val = constructObjectPropertyBool "local-only" val++data FileChooserLocalOnlyPropertyInfo+instance AttrInfo FileChooserLocalOnlyPropertyInfo where+    type AttrAllowedOps FileChooserLocalOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserLocalOnlyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserLocalOnlyPropertyInfo = FileChooserK+    type AttrGetType FileChooserLocalOnlyPropertyInfo = Bool+    type AttrLabel FileChooserLocalOnlyPropertyInfo = "FileChooser::local-only"+    attrGet _ = getFileChooserLocalOnly+    attrSet _ = setFileChooserLocalOnly+    attrConstruct _ = constructFileChooserLocalOnly++-- VVV Prop "preview-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserPreviewWidget :: (MonadIO m, FileChooserK o) => o -> m Widget+getFileChooserPreviewWidget obj = liftIO $ getObjectPropertyObject obj "preview-widget" Widget++setFileChooserPreviewWidget :: (MonadIO m, FileChooserK o, WidgetK a) => o -> a -> m ()+setFileChooserPreviewWidget obj val = liftIO $ setObjectPropertyObject obj "preview-widget" val++constructFileChooserPreviewWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructFileChooserPreviewWidget val = constructObjectPropertyObject "preview-widget" val++data FileChooserPreviewWidgetPropertyInfo+instance AttrInfo FileChooserPreviewWidgetPropertyInfo where+    type AttrAllowedOps FileChooserPreviewWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserPreviewWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint FileChooserPreviewWidgetPropertyInfo = FileChooserK+    type AttrGetType FileChooserPreviewWidgetPropertyInfo = Widget+    type AttrLabel FileChooserPreviewWidgetPropertyInfo = "FileChooser::preview-widget"+    attrGet _ = getFileChooserPreviewWidget+    attrSet _ = setFileChooserPreviewWidget+    attrConstruct _ = constructFileChooserPreviewWidget++-- VVV Prop "preview-widget-active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserPreviewWidgetActive :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserPreviewWidgetActive obj = liftIO $ getObjectPropertyBool obj "preview-widget-active"++setFileChooserPreviewWidgetActive :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserPreviewWidgetActive obj val = liftIO $ setObjectPropertyBool obj "preview-widget-active" val++constructFileChooserPreviewWidgetActive :: Bool -> IO ([Char], GValue)+constructFileChooserPreviewWidgetActive val = constructObjectPropertyBool "preview-widget-active" val++data FileChooserPreviewWidgetActivePropertyInfo+instance AttrInfo FileChooserPreviewWidgetActivePropertyInfo where+    type AttrAllowedOps FileChooserPreviewWidgetActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserPreviewWidgetActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserPreviewWidgetActivePropertyInfo = FileChooserK+    type AttrGetType FileChooserPreviewWidgetActivePropertyInfo = Bool+    type AttrLabel FileChooserPreviewWidgetActivePropertyInfo = "FileChooser::preview-widget-active"+    attrGet _ = getFileChooserPreviewWidgetActive+    attrSet _ = setFileChooserPreviewWidgetActive+    attrConstruct _ = constructFileChooserPreviewWidgetActive++-- VVV Prop "select-multiple"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserSelectMultiple :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserSelectMultiple obj = liftIO $ getObjectPropertyBool obj "select-multiple"++setFileChooserSelectMultiple :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserSelectMultiple obj val = liftIO $ setObjectPropertyBool obj "select-multiple" val++constructFileChooserSelectMultiple :: Bool -> IO ([Char], GValue)+constructFileChooserSelectMultiple val = constructObjectPropertyBool "select-multiple" val++data FileChooserSelectMultiplePropertyInfo+instance AttrInfo FileChooserSelectMultiplePropertyInfo where+    type AttrAllowedOps FileChooserSelectMultiplePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserSelectMultiplePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserSelectMultiplePropertyInfo = FileChooserK+    type AttrGetType FileChooserSelectMultiplePropertyInfo = Bool+    type AttrLabel FileChooserSelectMultiplePropertyInfo = "FileChooser::select-multiple"+    attrGet _ = getFileChooserSelectMultiple+    attrSet _ = setFileChooserSelectMultiple+    attrConstruct _ = constructFileChooserSelectMultiple++-- VVV Prop "show-hidden"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserShowHidden :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserShowHidden obj = liftIO $ getObjectPropertyBool obj "show-hidden"++setFileChooserShowHidden :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserShowHidden obj val = liftIO $ setObjectPropertyBool obj "show-hidden" val++constructFileChooserShowHidden :: Bool -> IO ([Char], GValue)+constructFileChooserShowHidden val = constructObjectPropertyBool "show-hidden" val++data FileChooserShowHiddenPropertyInfo+instance AttrInfo FileChooserShowHiddenPropertyInfo where+    type AttrAllowedOps FileChooserShowHiddenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserShowHiddenPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserShowHiddenPropertyInfo = FileChooserK+    type AttrGetType FileChooserShowHiddenPropertyInfo = Bool+    type AttrLabel FileChooserShowHiddenPropertyInfo = "FileChooser::show-hidden"+    attrGet _ = getFileChooserShowHidden+    attrSet _ = setFileChooserShowHidden+    attrConstruct _ = constructFileChooserShowHidden++-- VVV Prop "use-preview-label"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserUsePreviewLabel :: (MonadIO m, FileChooserK o) => o -> m Bool+getFileChooserUsePreviewLabel obj = liftIO $ getObjectPropertyBool obj "use-preview-label"++setFileChooserUsePreviewLabel :: (MonadIO m, FileChooserK o) => o -> Bool -> m ()+setFileChooserUsePreviewLabel obj val = liftIO $ setObjectPropertyBool obj "use-preview-label" val++constructFileChooserUsePreviewLabel :: Bool -> IO ([Char], GValue)+constructFileChooserUsePreviewLabel val = constructObjectPropertyBool "use-preview-label" val++data FileChooserUsePreviewLabelPropertyInfo+instance AttrInfo FileChooserUsePreviewLabelPropertyInfo where+    type AttrAllowedOps FileChooserUsePreviewLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserUsePreviewLabelPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserUsePreviewLabelPropertyInfo = FileChooserK+    type AttrGetType FileChooserUsePreviewLabelPropertyInfo = Bool+    type AttrLabel FileChooserUsePreviewLabelPropertyInfo = "FileChooser::use-preview-label"+    attrGet _ = getFileChooserUsePreviewLabel+    attrSet _ = setFileChooserUsePreviewLabel+    attrConstruct _ = constructFileChooserUsePreviewLabel++type instance AttributeList FileChooser = FileChooserAttributeList+type FileChooserAttributeList = ('[ '("action", FileChooserActionPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("create-folders", FileChooserCreateFoldersPropertyInfo), '("do-overwrite-confirmation", FileChooserDoOverwriteConfirmationPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("extra-widget", FileChooserExtraWidgetPropertyInfo), '("filter", FileChooserFilterPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("local-only", FileChooserLocalOnlyPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-widget", FileChooserPreviewWidgetPropertyInfo), '("preview-widget-active", FileChooserPreviewWidgetActivePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("select-multiple", FileChooserSelectMultiplePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-hidden", FileChooserShowHiddenPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-preview-label", FileChooserUsePreviewLabelPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data FileChooserConfirmOverwriteSignalInfo+instance SignalInfo FileChooserConfirmOverwriteSignalInfo where+    type HaskellCallbackType FileChooserConfirmOverwriteSignalInfo = FileChooserConfirmOverwriteCallback+    connectSignal _ = connectFileChooserConfirmOverwrite++data FileChooserCurrentFolderChangedSignalInfo+instance SignalInfo FileChooserCurrentFolderChangedSignalInfo where+    type HaskellCallbackType FileChooserCurrentFolderChangedSignalInfo = FileChooserCurrentFolderChangedCallback+    connectSignal _ = connectFileChooserCurrentFolderChanged++data FileChooserFileActivatedSignalInfo+instance SignalInfo FileChooserFileActivatedSignalInfo where+    type HaskellCallbackType FileChooserFileActivatedSignalInfo = FileChooserFileActivatedCallback+    connectSignal _ = connectFileChooserFileActivated++data FileChooserSelectionChangedSignalInfo+instance SignalInfo FileChooserSelectionChangedSignalInfo where+    type HaskellCallbackType FileChooserSelectionChangedSignalInfo = FileChooserSelectionChangedCallback+    connectSignal _ = connectFileChooserSelectionChanged++data FileChooserUpdatePreviewSignalInfo+instance SignalInfo FileChooserUpdatePreviewSignalInfo where+    type HaskellCallbackType FileChooserUpdatePreviewSignalInfo = FileChooserUpdatePreviewCallback+    connectSignal _ = connectFileChooserUpdatePreview++type instance SignalList FileChooser = FileChooserSignalList+type FileChooserSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("confirm-overwrite", FileChooserConfirmOverwriteSignalInfo), '("current-folder-changed", FileChooserCurrentFolderChangedSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("file-activated", FileChooserFileActivatedSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-changed", FileChooserSelectionChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("update-preview", FileChooserUpdatePreviewSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_file_chooser_get_type"+    c_gtk_file_chooser_get_type :: IO GType++type instance ParentTypes FileChooser = FileChooserParentTypes+type FileChooserParentTypes = '[Widget, GObject.Object]++instance GObject FileChooser where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_file_chooser_get_type+    ++class GObject o => FileChooserK o+instance (GObject o, IsDescendantOf FileChooser o) => FileChooserK o++toFileChooser :: FileChooserK o => o -> IO FileChooser+toFileChooser = unsafeCastTo FileChooser++-- method FileChooser::add_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_add_filter" gtk_file_chooser_add_filter :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr FileFilter ->                       -- filter : TInterface "Gtk" "FileFilter"+    IO ()+++fileChooserAddFilter ::+    (MonadIO m, FileChooserK a, FileFilterK b) =>+    a ->                                    -- _obj+    b ->                                    -- filter+    m ()+fileChooserAddFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filter' <- refObject filter+    gtk_file_chooser_add_filter _obj' filter'+    touchManagedPtr _obj+    touchManagedPtr filter+    return ()++-- method FileChooser::add_shortcut_folder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "folder", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "folder", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_add_shortcut_folder" gtk_file_chooser_add_shortcut_folder :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- folder : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserAddShortcutFolder ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- folder+    m ()+fileChooserAddShortcutFolder _obj folder = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    folder' <- stringToCString folder+    onException (do+        _ <- propagateGError $ gtk_file_chooser_add_shortcut_folder _obj' folder'+        touchManagedPtr _obj+        freeMem folder'+        return ()+     ) (do+        freeMem folder'+     )++-- method FileChooser::add_shortcut_folder_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_add_shortcut_folder_uri" gtk_file_chooser_add_shortcut_folder_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserAddShortcutFolderUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+fileChooserAddShortcutFolderUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gtk_file_chooser_add_shortcut_folder_uri _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++-- method FileChooser::get_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileChooserAction"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_action" gtk_file_chooser_get_action :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CUInt+++fileChooserGetAction ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m FileChooserAction+fileChooserGetAction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_action _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_create_folders+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_create_folders" gtk_file_chooser_get_create_folders :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetCreateFolders ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetCreateFolders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_create_folders _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_current_folder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_current_folder" gtk_file_chooser_get_current_folder :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetCurrentFolder ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [Char]+fileChooserGetCurrentFolder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_current_folder _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_current_folder" result+    result' <- cstringToString result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_current_folder_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_current_folder_file" gtk_file_chooser_get_current_folder_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr Gio.File)+++fileChooserGetCurrentFolderFile ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Gio.File+fileChooserGetCurrentFolderFile _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_current_folder_file _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_current_folder_file" result+    result' <- (wrapObject Gio.File) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_current_folder_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_current_folder_uri" gtk_file_chooser_get_current_folder_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetCurrentFolderUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fileChooserGetCurrentFolderUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_current_folder_uri _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_current_folder_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_current_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_current_name" gtk_file_chooser_get_current_name :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetCurrentName ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fileChooserGetCurrentName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_current_name _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_current_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_do_overwrite_confirmation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_do_overwrite_confirmation" gtk_file_chooser_get_do_overwrite_confirmation :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetDoOverwriteConfirmation ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetDoOverwriteConfirmation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_do_overwrite_confirmation _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_extra_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_extra_widget" gtk_file_chooser_get_extra_widget :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr Widget)+++fileChooserGetExtraWidget ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Widget+fileChooserGetExtraWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_extra_widget _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_extra_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_file" gtk_file_chooser_get_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr Gio.File)+++fileChooserGetFile ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Gio.File+fileChooserGetFile _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_file _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_file" result+    result' <- (wrapObject Gio.File) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_filename" gtk_file_chooser_get_filename :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetFilename ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [Char]+fileChooserGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_filename _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_filename" result+    result' <- cstringToString result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_filenames+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TBasicType TFileName)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_filenames" gtk_file_chooser_get_filenames :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList CString))+++fileChooserGetFilenames ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [[Char]]+fileChooserGetFilenames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_filenames _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_filenames" result+    result' <- unpackGSList result+    result'' <- mapM cstringToString result'+    mapGSList freeMem result+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::get_files+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gio" "File")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_files" gtk_file_chooser_get_files :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList (Ptr Gio.File)))+++fileChooserGetFiles ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [Gio.File]+fileChooserGetFiles _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_files _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_files" result+    result' <- unpackGSList result+    result'' <- mapM (wrapObject Gio.File) result'+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::get_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileFilter"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_filter" gtk_file_chooser_get_filter :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr FileFilter)+++fileChooserGetFilter ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m FileFilter+fileChooserGetFilter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_filter _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_filter" result+    result' <- (newObject FileFilter) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_local_only" gtk_file_chooser_get_local_only :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetLocalOnly ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetLocalOnly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_local_only _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_preview_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_preview_file" gtk_file_chooser_get_preview_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr Gio.File)+++fileChooserGetPreviewFile ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Gio.File+fileChooserGetPreviewFile _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_preview_file _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_preview_file" result+    result' <- (wrapObject Gio.File) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_preview_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_preview_filename" gtk_file_chooser_get_preview_filename :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetPreviewFilename ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [Char]+fileChooserGetPreviewFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_preview_filename _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_preview_filename" result+    result' <- cstringToString result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_preview_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_preview_uri" gtk_file_chooser_get_preview_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetPreviewUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fileChooserGetPreviewUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_preview_uri _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_preview_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_preview_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_preview_widget" gtk_file_chooser_get_preview_widget :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr Widget)+++fileChooserGetPreviewWidget ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Widget+fileChooserGetPreviewWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_preview_widget _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_preview_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_preview_widget_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_preview_widget_active" gtk_file_chooser_get_preview_widget_active :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetPreviewWidgetActive ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetPreviewWidgetActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_preview_widget_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_select_multiple+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_select_multiple" gtk_file_chooser_get_select_multiple :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetSelectMultiple ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetSelectMultiple _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_select_multiple _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_show_hidden+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_show_hidden" gtk_file_chooser_get_show_hidden :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetShowHidden ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetShowHidden _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_show_hidden _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_uri" gtk_file_chooser_get_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CString+++fileChooserGetUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fileChooserGetUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_uri _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FileChooser::get_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_uris" gtk_file_chooser_get_uris :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList CString))+++fileChooserGetUris ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [T.Text]+fileChooserGetUris _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_uris _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_get_uris" result+    result' <- unpackGSList result+    result'' <- mapM cstringToText result'+    mapGSList freeMem result+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::get_use_preview_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_get_use_preview_label" gtk_file_chooser_get_use_preview_label :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO CInt+++fileChooserGetUsePreviewLabel ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserGetUsePreviewLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_get_use_preview_label _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooser::list_filters+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "FileFilter")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_list_filters" gtk_file_chooser_list_filters :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList (Ptr FileFilter)))+++fileChooserListFilters ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [FileFilter]+fileChooserListFilters _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_list_filters _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_list_filters" result+    result' <- unpackGSList result+    result'' <- mapM (newObject FileFilter) result'+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::list_shortcut_folder_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_list_shortcut_folder_uris" gtk_file_chooser_list_shortcut_folder_uris :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList CString))+++fileChooserListShortcutFolderUris ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [T.Text]+fileChooserListShortcutFolderUris _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_list_shortcut_folder_uris _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_list_shortcut_folder_uris" result+    result' <- unpackGSList result+    result'' <- mapM cstringToText result'+    mapGSList freeMem result+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::list_shortcut_folders+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TBasicType TFileName)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_list_shortcut_folders" gtk_file_chooser_list_shortcut_folders :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO (Ptr (GSList CString))+++fileChooserListShortcutFolders ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m [[Char]]+fileChooserListShortcutFolders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_list_shortcut_folders _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_list_shortcut_folders" result+    result' <- unpackGSList result+    result'' <- mapM cstringToString result'+    mapGSList freeMem result+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method FileChooser::remove_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_remove_filter" gtk_file_chooser_remove_filter :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr FileFilter ->                       -- filter : TInterface "Gtk" "FileFilter"+    IO ()+++fileChooserRemoveFilter ::+    (MonadIO m, FileChooserK a, FileFilterK b) =>+    a ->                                    -- _obj+    b ->                                    -- filter+    m ()+fileChooserRemoveFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let filter' = unsafeManagedPtrCastPtr filter+    gtk_file_chooser_remove_filter _obj' filter'+    touchManagedPtr _obj+    touchManagedPtr filter+    return ()++-- method FileChooser::remove_shortcut_folder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "folder", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "folder", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_remove_shortcut_folder" gtk_file_chooser_remove_shortcut_folder :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- folder : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserRemoveShortcutFolder ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- folder+    m ()+fileChooserRemoveShortcutFolder _obj folder = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    folder' <- stringToCString folder+    onException (do+        _ <- propagateGError $ gtk_file_chooser_remove_shortcut_folder _obj' folder'+        touchManagedPtr _obj+        freeMem folder'+        return ()+     ) (do+        freeMem folder'+     )++-- method FileChooser::remove_shortcut_folder_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_remove_shortcut_folder_uri" gtk_file_chooser_remove_shortcut_folder_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserRemoveShortcutFolderUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+fileChooserRemoveShortcutFolderUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gtk_file_chooser_remove_shortcut_folder_uri _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++-- method FileChooser::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_select_all" gtk_file_chooser_select_all :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO ()+++fileChooserSelectAll ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m ()+fileChooserSelectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_file_chooser_select_all _obj'+    touchManagedPtr _obj+    return ()++-- method FileChooser::select_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_select_file" gtk_file_chooser_select_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserSelectFile ::+    (MonadIO m, FileChooserK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file+    m ()+fileChooserSelectFile _obj file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file' = unsafeManagedPtrCastPtr file+    onException (do+        _ <- propagateGError $ gtk_file_chooser_select_file _obj' file'+        touchManagedPtr _obj+        touchManagedPtr file+        return ()+     ) (do+        return ()+     )++-- method FileChooser::select_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_select_filename" gtk_file_chooser_select_filename :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- filename : TBasicType TFileName+    IO CInt+++fileChooserSelectFilename ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- filename+    m Bool+fileChooserSelectFilename _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- stringToCString filename+    result <- gtk_file_chooser_select_filename _obj' filename'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem filename'+    return result'++-- method FileChooser::select_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_select_uri" gtk_file_chooser_select_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    IO CInt+++fileChooserSelectUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m Bool+fileChooserSelectUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    result <- gtk_file_chooser_select_uri _obj' uri'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem uri'+    return result'++-- method FileChooser::set_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_action" gtk_file_chooser_set_action :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CUInt ->                                -- action : TInterface "Gtk" "FileChooserAction"+    IO ()+++fileChooserSetAction ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    FileChooserAction ->                    -- action+    m ()+fileChooserSetAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = (fromIntegral . fromEnum) action+    gtk_file_chooser_set_action _obj' action'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_create_folders+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "create_folders", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "create_folders", 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 "gtk_file_chooser_set_create_folders" gtk_file_chooser_set_create_folders :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- create_folders : TBasicType TBoolean+    IO ()+++fileChooserSetCreateFolders ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- create_folders+    m ()+fileChooserSetCreateFolders _obj create_folders = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let create_folders' = (fromIntegral . fromEnum) create_folders+    gtk_file_chooser_set_create_folders _obj' create_folders'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_current_folder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_current_folder" gtk_file_chooser_set_current_folder :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- filename : TBasicType TFileName+    IO CInt+++fileChooserSetCurrentFolder ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- filename+    m Bool+fileChooserSetCurrentFolder _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- stringToCString filename+    result <- gtk_file_chooser_set_current_folder _obj' filename'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem filename'+    return result'++-- method FileChooser::set_current_folder_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_current_folder_file" gtk_file_chooser_set_current_folder_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserSetCurrentFolderFile ::+    (MonadIO m, FileChooserK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file+    m ()+fileChooserSetCurrentFolderFile _obj file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file' = unsafeManagedPtrCastPtr file+    onException (do+        _ <- propagateGError $ gtk_file_chooser_set_current_folder_file _obj' file'+        touchManagedPtr _obj+        touchManagedPtr file+        return ()+     ) (do+        return ()+     )++-- method FileChooser::set_current_folder_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_current_folder_uri" gtk_file_chooser_set_current_folder_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    IO CInt+++fileChooserSetCurrentFolderUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m Bool+fileChooserSetCurrentFolderUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    result <- gtk_file_chooser_set_current_folder_uri _obj' uri'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem uri'+    return result'++-- method FileChooser::set_current_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_current_name" gtk_file_chooser_set_current_name :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- name : TBasicType TFileName+    IO ()+++fileChooserSetCurrentName ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- name+    m ()+fileChooserSetCurrentName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- stringToCString name+    gtk_file_chooser_set_current_name _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method FileChooser::set_do_overwrite_confirmation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "do_overwrite_confirmation", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "do_overwrite_confirmation", 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 "gtk_file_chooser_set_do_overwrite_confirmation" gtk_file_chooser_set_do_overwrite_confirmation :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- do_overwrite_confirmation : TBasicType TBoolean+    IO ()+++fileChooserSetDoOverwriteConfirmation ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- do_overwrite_confirmation+    m ()+fileChooserSetDoOverwriteConfirmation _obj do_overwrite_confirmation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let do_overwrite_confirmation' = (fromIntegral . fromEnum) do_overwrite_confirmation+    gtk_file_chooser_set_do_overwrite_confirmation _obj' do_overwrite_confirmation'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_extra_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extra_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "extra_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_extra_widget" gtk_file_chooser_set_extra_widget :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Widget ->                           -- extra_widget : TInterface "Gtk" "Widget"+    IO ()+++fileChooserSetExtraWidget ::+    (MonadIO m, FileChooserK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- extra_widget+    m ()+fileChooserSetExtraWidget _obj extra_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let extra_widget' = unsafeManagedPtrCastPtr extra_widget+    gtk_file_chooser_set_extra_widget _obj' extra_widget'+    touchManagedPtr _obj+    touchManagedPtr extra_widget+    return ()++-- method FileChooser::set_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_file" gtk_file_chooser_set_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++fileChooserSetFile ::+    (MonadIO m, FileChooserK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file+    m ()+fileChooserSetFile _obj file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file' = unsafeManagedPtrCastPtr file+    onException (do+        _ <- propagateGError $ gtk_file_chooser_set_file _obj' file'+        touchManagedPtr _obj+        touchManagedPtr file+        return ()+     ) (do+        return ()+     )++-- method FileChooser::set_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_filename" gtk_file_chooser_set_filename :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- filename : TBasicType TFileName+    IO CInt+++fileChooserSetFilename ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- filename+    m Bool+fileChooserSetFilename _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- stringToCString filename+    result <- gtk_file_chooser_set_filename _obj' filename'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem filename'+    return result'++-- method FileChooser::set_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_filter" gtk_file_chooser_set_filter :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr FileFilter ->                       -- filter : TInterface "Gtk" "FileFilter"+    IO ()+++fileChooserSetFilter ::+    (MonadIO m, FileChooserK a, FileFilterK b) =>+    a ->                                    -- _obj+    b ->                                    -- filter+    m ()+fileChooserSetFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let filter' = unsafeManagedPtrCastPtr filter+    gtk_file_chooser_set_filter _obj' filter'+    touchManagedPtr _obj+    touchManagedPtr filter+    return ()++-- method FileChooser::set_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_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 "gtk_file_chooser_set_local_only" gtk_file_chooser_set_local_only :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- local_only : TBasicType TBoolean+    IO ()+++fileChooserSetLocalOnly ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- local_only+    m ()+fileChooserSetLocalOnly _obj local_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let local_only' = (fromIntegral . fromEnum) local_only+    gtk_file_chooser_set_local_only _obj' local_only'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_preview_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "preview_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "preview_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_preview_widget" gtk_file_chooser_set_preview_widget :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Widget ->                           -- preview_widget : TInterface "Gtk" "Widget"+    IO ()+++fileChooserSetPreviewWidget ::+    (MonadIO m, FileChooserK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- preview_widget+    m ()+fileChooserSetPreviewWidget _obj preview_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let preview_widget' = unsafeManagedPtrCastPtr preview_widget+    gtk_file_chooser_set_preview_widget _obj' preview_widget'+    touchManagedPtr _obj+    touchManagedPtr preview_widget+    return ()++-- method FileChooser::set_preview_widget_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "active", 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 "gtk_file_chooser_set_preview_widget_active" gtk_file_chooser_set_preview_widget_active :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- active : TBasicType TBoolean+    IO ()+++fileChooserSetPreviewWidgetActive ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- active+    m ()+fileChooserSetPreviewWidgetActive _obj active = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let active' = (fromIntegral . fromEnum) active+    gtk_file_chooser_set_preview_widget_active _obj' active'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_select_multiple+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "select_multiple", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "select_multiple", 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 "gtk_file_chooser_set_select_multiple" gtk_file_chooser_set_select_multiple :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- select_multiple : TBasicType TBoolean+    IO ()+++fileChooserSetSelectMultiple ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- select_multiple+    m ()+fileChooserSetSelectMultiple _obj select_multiple = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let select_multiple' = (fromIntegral . fromEnum) select_multiple+    gtk_file_chooser_set_select_multiple _obj' select_multiple'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_show_hidden+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_hidden", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_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 "gtk_file_chooser_set_show_hidden" gtk_file_chooser_set_show_hidden :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- show_hidden : TBasicType TBoolean+    IO ()+++fileChooserSetShowHidden ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_hidden+    m ()+fileChooserSetShowHidden _obj show_hidden = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_hidden' = (fromIntegral . fromEnum) show_hidden+    gtk_file_chooser_set_show_hidden _obj' show_hidden'+    touchManagedPtr _obj+    return ()++-- method FileChooser::set_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_set_uri" gtk_file_chooser_set_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    IO CInt+++fileChooserSetUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m Bool+fileChooserSetUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    result <- gtk_file_chooser_set_uri _obj' uri'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem uri'+    return result'++-- method FileChooser::set_use_preview_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_label", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_label", 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 "gtk_file_chooser_set_use_preview_label" gtk_file_chooser_set_use_preview_label :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CInt ->                                 -- use_label : TBasicType TBoolean+    IO ()+++fileChooserSetUsePreviewLabel ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_label+    m ()+fileChooserSetUsePreviewLabel _obj use_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_label' = (fromIntegral . fromEnum) use_label+    gtk_file_chooser_set_use_preview_label _obj' use_label'+    touchManagedPtr _obj+    return ()++-- method FileChooser::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_unselect_all" gtk_file_chooser_unselect_all :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    IO ()+++fileChooserUnselectAll ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    m ()+fileChooserUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_file_chooser_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method FileChooser::unselect_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_unselect_file" gtk_file_chooser_unselect_file :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    IO ()+++fileChooserUnselectFile ::+    (MonadIO m, FileChooserK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file+    m ()+fileChooserUnselectFile _obj file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file' = unsafeManagedPtrCastPtr file+    gtk_file_chooser_unselect_file _obj' file'+    touchManagedPtr _obj+    touchManagedPtr file+    return ()++-- method FileChooser::unselect_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_unselect_filename" gtk_file_chooser_unselect_filename :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- filename : TBasicType TFileName+    IO ()+++fileChooserUnselectFilename ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- filename+    m ()+fileChooserUnselectFilename _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- stringToCString filename+    gtk_file_chooser_unselect_filename _obj' filename'+    touchManagedPtr _obj+    freeMem filename'+    return ()++-- method FileChooser::unselect_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooser", 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 "Gtk" "FileChooser", 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_unselect_uri" gtk_file_chooser_unselect_uri :: +    Ptr FileChooser ->                      -- _obj : TInterface "Gtk" "FileChooser"+    CString ->                              -- uri : TBasicType TUTF8+    IO ()+++fileChooserUnselectUri ::+    (MonadIO m, FileChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+fileChooserUnselectUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    gtk_file_chooser_unselect_uri _obj' uri'+    touchManagedPtr _obj+    freeMem uri'+    return ()++
+ GI/Gtk/Interfaces/FileChooser.hs-boot view
@@ -0,0 +1,29 @@+module GI.Gtk.Interfaces.FileChooser where++import Prelude ()+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 FileChooser = FileChooser (ForeignPtr FileChooser)+data FileChooserActionPropertyInfo+data FileChooserCreateFoldersPropertyInfo+data FileChooserDoOverwriteConfirmationPropertyInfo+data FileChooserExtraWidgetPropertyInfo+data FileChooserFilterPropertyInfo+data FileChooserLocalOnlyPropertyInfo+data FileChooserPreviewWidgetPropertyInfo+data FileChooserPreviewWidgetActivePropertyInfo+data FileChooserSelectMultiplePropertyInfo+data FileChooserShowHiddenPropertyInfo+data FileChooserUsePreviewLabelPropertyInfo+data FileChooserConfirmOverwriteSignalInfo+data FileChooserCurrentFolderChangedSignalInfo+data FileChooserFileActivatedSignalInfo+data FileChooserSelectionChangedSignalInfo+data FileChooserUpdatePreviewSignalInfo+instance GObject FileChooser where+class GObject o => FileChooserK o+instance (GObject o, IsDescendantOf FileChooser o) => FileChooserK o
+ GI/Gtk/Interfaces/FontChooser.hs view
@@ -0,0 +1,695 @@++{- |+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.Gtk.Interfaces.FontChooser+    ( ++-- * Exported types+    FontChooser(..)                         ,+    noFontChooser                           ,+    FontChooserK                            ,+    toFontChooser                           ,+++ -- * Methods+-- ** fontChooserGetFont+    fontChooserGetFont                      ,+++-- ** fontChooserGetFontDesc+    fontChooserGetFontDesc                  ,+++-- ** fontChooserGetFontFace+    fontChooserGetFontFace                  ,+++-- ** fontChooserGetFontFamily+    fontChooserGetFontFamily                ,+++-- ** fontChooserGetFontMap+    fontChooserGetFontMap                   ,+++-- ** fontChooserGetFontSize+    fontChooserGetFontSize                  ,+++-- ** fontChooserGetPreviewText+    fontChooserGetPreviewText               ,+++-- ** fontChooserGetShowPreviewEntry+    fontChooserGetShowPreviewEntry          ,+++-- ** fontChooserSetFilterFunc+    fontChooserSetFilterFunc                ,+++-- ** fontChooserSetFont+    fontChooserSetFont                      ,+++-- ** fontChooserSetFontDesc+    fontChooserSetFontDesc                  ,+++-- ** fontChooserSetFontMap+    fontChooserSetFontMap                   ,+++-- ** fontChooserSetPreviewText+    fontChooserSetPreviewText               ,+++-- ** fontChooserSetShowPreviewEntry+    fontChooserSetShowPreviewEntry          ,+++++ -- * Properties+-- ** Font+    FontChooserFontPropertyInfo             ,+    constructFontChooserFont                ,+    getFontChooserFont                      ,+    setFontChooserFont                      ,+++-- ** FontDesc+    FontChooserFontDescPropertyInfo         ,+    constructFontChooserFontDesc            ,+    getFontChooserFontDesc                  ,+    setFontChooserFontDesc                  ,+++-- ** PreviewText+    FontChooserPreviewTextPropertyInfo      ,+    constructFontChooserPreviewText         ,+    getFontChooserPreviewText               ,+    setFontChooserPreviewText               ,+++-- ** ShowPreviewEntry+    FontChooserShowPreviewEntryPropertyInfo ,+    constructFontChooserShowPreviewEntry    ,+    getFontChooserShowPreviewEntry          ,+    setFontChooserShowPreviewEntry          ,+++++ -- * Signals+-- ** FontActivated+    FontChooserFontActivatedCallback        ,+    FontChooserFontActivatedCallbackC       ,+    FontChooserFontActivatedSignalInfo      ,+    afterFontChooserFontActivated           ,+    fontChooserFontActivatedCallbackWrapper ,+    fontChooserFontActivatedClosure         ,+    mkFontChooserFontActivatedCallback      ,+    noFontChooserFontActivatedCallback      ,+    onFontChooserFontActivated              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango++-- interface FontChooser ++newtype FontChooser = FontChooser (ForeignPtr FontChooser)+noFontChooser :: Maybe FontChooser+noFontChooser = Nothing++-- signal FontChooser::font-activated+type FontChooserFontActivatedCallback =+    T.Text ->+    IO ()++noFontChooserFontActivatedCallback :: Maybe FontChooserFontActivatedCallback+noFontChooserFontActivatedCallback = Nothing++type FontChooserFontActivatedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFontChooserFontActivatedCallback :: FontChooserFontActivatedCallbackC -> IO (FunPtr FontChooserFontActivatedCallbackC)++fontChooserFontActivatedClosure :: FontChooserFontActivatedCallback -> IO Closure+fontChooserFontActivatedClosure cb = newCClosure =<< mkFontChooserFontActivatedCallback wrapped+    where wrapped = fontChooserFontActivatedCallbackWrapper cb++fontChooserFontActivatedCallbackWrapper ::+    FontChooserFontActivatedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+fontChooserFontActivatedCallbackWrapper _cb _ fontname _ = do+    fontname' <- cstringToText fontname+    _cb  fontname'++onFontChooserFontActivated :: (GObject a, MonadIO m) => a -> FontChooserFontActivatedCallback -> m SignalHandlerId+onFontChooserFontActivated obj cb = liftIO $ connectFontChooserFontActivated obj cb SignalConnectBefore+afterFontChooserFontActivated :: (GObject a, MonadIO m) => a -> FontChooserFontActivatedCallback -> m SignalHandlerId+afterFontChooserFontActivated obj cb = connectFontChooserFontActivated obj cb SignalConnectAfter++connectFontChooserFontActivated :: (GObject a, MonadIO m) =>+                                   a -> FontChooserFontActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectFontChooserFontActivated obj cb after = liftIO $ do+    cb' <- mkFontChooserFontActivatedCallback (fontChooserFontActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "font-activated" cb' after++-- VVV Prop "font"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontChooserFont :: (MonadIO m, FontChooserK o) => o -> m T.Text+getFontChooserFont obj = liftIO $ getObjectPropertyString obj "font"++setFontChooserFont :: (MonadIO m, FontChooserK o) => o -> T.Text -> m ()+setFontChooserFont obj val = liftIO $ setObjectPropertyString obj "font" val++constructFontChooserFont :: T.Text -> IO ([Char], GValue)+constructFontChooserFont val = constructObjectPropertyString "font" val++data FontChooserFontPropertyInfo+instance AttrInfo FontChooserFontPropertyInfo where+    type AttrAllowedOps FontChooserFontPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontChooserFontPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontChooserFontPropertyInfo = FontChooserK+    type AttrGetType FontChooserFontPropertyInfo = T.Text+    type AttrLabel FontChooserFontPropertyInfo = "FontChooser::font"+    attrGet _ = getFontChooserFont+    attrSet _ = setFontChooserFont+    attrConstruct _ = constructFontChooserFont++-- VVV Prop "font-desc"+   -- Type: TInterface "Pango" "FontDescription"+   -- Flags: [PropertyReadable,PropertyWritable]++getFontChooserFontDesc :: (MonadIO m, FontChooserK o) => o -> m Pango.FontDescription+getFontChooserFontDesc obj = liftIO $ getObjectPropertyBoxed obj "font-desc" Pango.FontDescription++setFontChooserFontDesc :: (MonadIO m, FontChooserK o) => o -> Pango.FontDescription -> m ()+setFontChooserFontDesc obj val = liftIO $ setObjectPropertyBoxed obj "font-desc" val++constructFontChooserFontDesc :: Pango.FontDescription -> IO ([Char], GValue)+constructFontChooserFontDesc val = constructObjectPropertyBoxed "font-desc" val++data FontChooserFontDescPropertyInfo+instance AttrInfo FontChooserFontDescPropertyInfo where+    type AttrAllowedOps FontChooserFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontChooserFontDescPropertyInfo = (~) Pango.FontDescription+    type AttrBaseTypeConstraint FontChooserFontDescPropertyInfo = FontChooserK+    type AttrGetType FontChooserFontDescPropertyInfo = Pango.FontDescription+    type AttrLabel FontChooserFontDescPropertyInfo = "FontChooser::font-desc"+    attrGet _ = getFontChooserFontDesc+    attrSet _ = setFontChooserFontDesc+    attrConstruct _ = constructFontChooserFontDesc++-- VVV Prop "preview-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontChooserPreviewText :: (MonadIO m, FontChooserK o) => o -> m T.Text+getFontChooserPreviewText obj = liftIO $ getObjectPropertyString obj "preview-text"++setFontChooserPreviewText :: (MonadIO m, FontChooserK o) => o -> T.Text -> m ()+setFontChooserPreviewText obj val = liftIO $ setObjectPropertyString obj "preview-text" val++constructFontChooserPreviewText :: T.Text -> IO ([Char], GValue)+constructFontChooserPreviewText val = constructObjectPropertyString "preview-text" val++data FontChooserPreviewTextPropertyInfo+instance AttrInfo FontChooserPreviewTextPropertyInfo where+    type AttrAllowedOps FontChooserPreviewTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontChooserPreviewTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontChooserPreviewTextPropertyInfo = FontChooserK+    type AttrGetType FontChooserPreviewTextPropertyInfo = T.Text+    type AttrLabel FontChooserPreviewTextPropertyInfo = "FontChooser::preview-text"+    attrGet _ = getFontChooserPreviewText+    attrSet _ = setFontChooserPreviewText+    attrConstruct _ = constructFontChooserPreviewText++-- VVV Prop "show-preview-entry"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFontChooserShowPreviewEntry :: (MonadIO m, FontChooserK o) => o -> m Bool+getFontChooserShowPreviewEntry obj = liftIO $ getObjectPropertyBool obj "show-preview-entry"++setFontChooserShowPreviewEntry :: (MonadIO m, FontChooserK o) => o -> Bool -> m ()+setFontChooserShowPreviewEntry obj val = liftIO $ setObjectPropertyBool obj "show-preview-entry" val++constructFontChooserShowPreviewEntry :: Bool -> IO ([Char], GValue)+constructFontChooserShowPreviewEntry val = constructObjectPropertyBool "show-preview-entry" val++data FontChooserShowPreviewEntryPropertyInfo+instance AttrInfo FontChooserShowPreviewEntryPropertyInfo where+    type AttrAllowedOps FontChooserShowPreviewEntryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontChooserShowPreviewEntryPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FontChooserShowPreviewEntryPropertyInfo = FontChooserK+    type AttrGetType FontChooserShowPreviewEntryPropertyInfo = Bool+    type AttrLabel FontChooserShowPreviewEntryPropertyInfo = "FontChooser::show-preview-entry"+    attrGet _ = getFontChooserShowPreviewEntry+    attrSet _ = setFontChooserShowPreviewEntry+    attrConstruct _ = constructFontChooserShowPreviewEntry++type instance AttributeList FontChooser = FontChooserAttributeList+type FontChooserAttributeList = ('[ '("font", FontChooserFontPropertyInfo), '("font-desc", FontChooserFontDescPropertyInfo), '("preview-text", FontChooserPreviewTextPropertyInfo), '("show-preview-entry", FontChooserShowPreviewEntryPropertyInfo)] :: [(Symbol, *)])++data FontChooserFontActivatedSignalInfo+instance SignalInfo FontChooserFontActivatedSignalInfo where+    type HaskellCallbackType FontChooserFontActivatedSignalInfo = FontChooserFontActivatedCallback+    connectSignal _ = connectFontChooserFontActivated++type instance SignalList FontChooser = FontChooserSignalList+type FontChooserSignalList = ('[ '("font-activated", FontChooserFontActivatedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_font_chooser_get_type"+    c_gtk_font_chooser_get_type :: IO GType++type instance ParentTypes FontChooser = FontChooserParentTypes+type FontChooserParentTypes = '[GObject.Object]++instance GObject FontChooser where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_font_chooser_get_type+    ++class GObject o => FontChooserK o+instance (GObject o, IsDescendantOf FontChooser o) => FontChooserK o++toFontChooser :: FontChooserK o => o -> IO FontChooser+toFontChooser = unsafeCastTo FontChooser++-- method FontChooser::get_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font" gtk_font_chooser_get_font :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO CString+++fontChooserGetFont ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fontChooserGetFont _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_font" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_font_desc+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontDescription"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font_desc" gtk_font_chooser_get_font_desc :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO (Ptr Pango.FontDescription)+++fontChooserGetFontDesc ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Pango.FontDescription+fontChooserGetFontDesc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font_desc _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_font_desc" result+    result' <- (wrapBoxed Pango.FontDescription) result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_font_face+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontFace"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font_face" gtk_font_chooser_get_font_face :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO (Ptr Pango.FontFace)+++fontChooserGetFontFace ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Pango.FontFace+fontChooserGetFontFace _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font_face _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_font_face" result+    result' <- (newObject Pango.FontFace) result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_font_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontFamily"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font_family" gtk_font_chooser_get_font_family :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO (Ptr Pango.FontFamily)+++fontChooserGetFontFamily ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Pango.FontFamily+fontChooserGetFontFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font_family _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_font_family" result+    result' <- (newObject Pango.FontFamily) result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_font_map+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontMap"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font_map" gtk_font_chooser_get_font_map :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO (Ptr Pango.FontMap)+++fontChooserGetFontMap ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Pango.FontMap+fontChooserGetFontMap _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font_map _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_font_map" result+    result' <- (wrapObject Pango.FontMap) result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_font_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_font_size" gtk_font_chooser_get_font_size :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO Int32+++fontChooserGetFontSize ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Int32+fontChooserGetFontSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_font_size _obj'+    touchManagedPtr _obj+    return result++-- method FontChooser::get_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_preview_text" gtk_font_chooser_get_preview_text :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO CString+++fontChooserGetPreviewText ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m T.Text+fontChooserGetPreviewText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_preview_text _obj'+    checkUnexpectedReturnNULL "gtk_font_chooser_get_preview_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FontChooser::get_show_preview_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_get_show_preview_entry" gtk_font_chooser_get_show_preview_entry :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    IO CInt+++fontChooserGetShowPreviewEntry ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    m Bool+fontChooserGetShowPreviewEntry _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_chooser_get_show_preview_entry _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontChooser::set_filter_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FontFilterFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "FontFilterFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_set_filter_func" gtk_font_chooser_set_filter_func :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    FunPtr FontFilterFuncC ->               -- filter : TInterface "Gtk" "FontFilterFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++fontChooserSetFilterFunc ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    Maybe (FontFilterFunc) ->               -- filter+    m ()+fontChooserSetFilterFunc _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter <- case filter of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFilter -> do+            jFilter' <- mkFontFilterFunc (fontFilterFuncWrapper Nothing jFilter)+            return jFilter'+    let user_data = castFunPtrToPtr maybeFilter+    let destroy = safeFreeFunPtrPtr+    gtk_font_chooser_set_filter_func _obj' maybeFilter user_data destroy+    touchManagedPtr _obj+    return ()++-- method FontChooser::set_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", 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 "gtk_font_chooser_set_font" gtk_font_chooser_set_font :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    CString ->                              -- fontname : TBasicType TUTF8+    IO ()+++fontChooserSetFont ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- fontname+    m ()+fontChooserSetFont _obj fontname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    fontname' <- textToCString fontname+    gtk_font_chooser_set_font _obj' fontname'+    touchManagedPtr _obj+    freeMem fontname'+    return ()++-- method FontChooser::set_font_desc+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "font_desc", argType = TInterface "Pango" "FontDescription", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "font_desc", argType = TInterface "Pango" "FontDescription", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_set_font_desc" gtk_font_chooser_set_font_desc :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    Ptr Pango.FontDescription ->            -- font_desc : TInterface "Pango" "FontDescription"+    IO ()+++fontChooserSetFontDesc ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    Pango.FontDescription ->                -- font_desc+    m ()+fontChooserSetFontDesc _obj font_desc = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let font_desc' = unsafeManagedPtrGetPtr font_desc+    gtk_font_chooser_set_font_desc _obj' font_desc'+    touchManagedPtr _obj+    touchManagedPtr font_desc+    return ()++-- method FontChooser::set_font_map+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontmap", argType = TInterface "Pango" "FontMap", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontmap", argType = TInterface "Pango" "FontMap", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_set_font_map" gtk_font_chooser_set_font_map :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    Ptr Pango.FontMap ->                    -- fontmap : TInterface "Pango" "FontMap"+    IO ()+++fontChooserSetFontMap ::+    (MonadIO m, FontChooserK a, Pango.FontMapK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- fontmap+    m ()+fontChooserSetFontMap _obj fontmap = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFontmap <- case fontmap of+        Nothing -> return nullPtr+        Just jFontmap -> do+            let jFontmap' = unsafeManagedPtrCastPtr jFontmap+            return jFontmap'+    gtk_font_chooser_set_font_map _obj' maybeFontmap+    touchManagedPtr _obj+    whenJust fontmap touchManagedPtr+    return ()++-- method FontChooser::set_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_font_chooser_set_preview_text" gtk_font_chooser_set_preview_text :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++fontChooserSetPreviewText ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+fontChooserSetPreviewText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_font_chooser_set_preview_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method FontChooser::set_show_preview_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_preview_entry", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_preview_entry", 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 "gtk_font_chooser_set_show_preview_entry" gtk_font_chooser_set_show_preview_entry :: +    Ptr FontChooser ->                      -- _obj : TInterface "Gtk" "FontChooser"+    CInt ->                                 -- show_preview_entry : TBasicType TBoolean+    IO ()+++fontChooserSetShowPreviewEntry ::+    (MonadIO m, FontChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_preview_entry+    m ()+fontChooserSetShowPreviewEntry _obj show_preview_entry = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_preview_entry' = (fromIntegral . fromEnum) show_preview_entry+    gtk_font_chooser_set_show_preview_entry _obj' show_preview_entry'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/FontChooser.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Interfaces.FontChooser where++import Prelude ()+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 FontChooser = FontChooser (ForeignPtr FontChooser)+data FontChooserFontPropertyInfo+data FontChooserFontDescPropertyInfo+data FontChooserPreviewTextPropertyInfo+data FontChooserShowPreviewEntryPropertyInfo+data FontChooserFontActivatedSignalInfo+instance GObject FontChooser where+class GObject o => FontChooserK o+instance (GObject o, IsDescendantOf FontChooser o) => FontChooserK o
+ GI/Gtk/Interfaces/Orientable.hs view
@@ -0,0 +1,157 @@++{- |+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.Gtk.Interfaces.Orientable+    ( ++-- * Exported types+    Orientable(..)                          ,+    noOrientable                            ,+    OrientableK                             ,+    toOrientable                            ,+++ -- * Methods+-- ** orientableGetOrientation+    orientableGetOrientation                ,+++-- ** orientableSetOrientation+    orientableSetOrientation                ,+++++ -- * Properties+-- ** Orientation+    OrientableOrientationPropertyInfo       ,+    constructOrientableOrientation          ,+    getOrientableOrientation                ,+    setOrientableOrientation                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface Orientable ++newtype Orientable = Orientable (ForeignPtr Orientable)+noOrientable :: Maybe Orientable+noOrientable = Nothing++-- VVV Prop "orientation"+   -- Type: TInterface "Gtk" "Orientation"+   -- Flags: [PropertyReadable,PropertyWritable]++getOrientableOrientation :: (MonadIO m, OrientableK o) => o -> m Orientation+getOrientableOrientation obj = liftIO $ getObjectPropertyEnum obj "orientation"++setOrientableOrientation :: (MonadIO m, OrientableK o) => o -> Orientation -> m ()+setOrientableOrientation obj val = liftIO $ setObjectPropertyEnum obj "orientation" val++constructOrientableOrientation :: Orientation -> IO ([Char], GValue)+constructOrientableOrientation val = constructObjectPropertyEnum "orientation" val++data OrientableOrientationPropertyInfo+instance AttrInfo OrientableOrientationPropertyInfo where+    type AttrAllowedOps OrientableOrientationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint OrientableOrientationPropertyInfo = (~) Orientation+    type AttrBaseTypeConstraint OrientableOrientationPropertyInfo = OrientableK+    type AttrGetType OrientableOrientationPropertyInfo = Orientation+    type AttrLabel OrientableOrientationPropertyInfo = "Orientable::orientation"+    attrGet _ = getOrientableOrientation+    attrSet _ = setOrientableOrientation+    attrConstruct _ = constructOrientableOrientation++type instance AttributeList Orientable = OrientableAttributeList+type OrientableAttributeList = ('[ '("orientation", OrientableOrientationPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Orientable = OrientableSignalList+type OrientableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_orientable_get_type"+    c_gtk_orientable_get_type :: IO GType++type instance ParentTypes Orientable = OrientableParentTypes+type OrientableParentTypes = '[GObject.Object]++instance GObject Orientable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_orientable_get_type+    ++class GObject o => OrientableK o+instance (GObject o, IsDescendantOf Orientable o) => OrientableK o++toOrientable :: OrientableK o => o -> IO Orientable+toOrientable = unsafeCastTo Orientable++-- method Orientable::get_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Orientable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Orientable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Orientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_orientable_get_orientation" gtk_orientable_get_orientation :: +    Ptr Orientable ->                       -- _obj : TInterface "Gtk" "Orientable"+    IO CUInt+++orientableGetOrientation ::+    (MonadIO m, OrientableK a) =>+    a ->                                    -- _obj+    m Orientation+orientableGetOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_orientable_get_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Orientable::set_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Orientable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Orientable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_orientable_set_orientation" gtk_orientable_set_orientation :: +    Ptr Orientable ->                       -- _obj : TInterface "Gtk" "Orientable"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()+++orientableSetOrientation ::+    (MonadIO m, OrientableK a) =>+    a ->                                    -- _obj+    Orientation ->                          -- orientation+    m ()+orientableSetOrientation _obj orientation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_orientable_set_orientation _obj' orientation'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/Orientable.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Interfaces.Orientable where++import Prelude ()+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 Orientable = Orientable (ForeignPtr Orientable)+data OrientableOrientationPropertyInfo+instance GObject Orientable where+class GObject o => OrientableK o+instance (GObject o, IsDescendantOf Orientable o) => OrientableK o
+ GI/Gtk/Interfaces/PrintOperationPreview.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.Gtk.Interfaces.PrintOperationPreview+    ( ++-- * Exported types+    PrintOperationPreview(..)               ,+    noPrintOperationPreview                 ,+    PrintOperationPreviewK                  ,+    toPrintOperationPreview                 ,+++ -- * Methods+-- ** printOperationPreviewEndPreview+    printOperationPreviewEndPreview         ,+++-- ** printOperationPreviewIsSelected+    printOperationPreviewIsSelected         ,+++-- ** printOperationPreviewRenderPage+    printOperationPreviewRenderPage         ,+++++ -- * Signals+-- ** GotPageSize+    PrintOperationPreviewGotPageSizeCallback,+    PrintOperationPreviewGotPageSizeCallbackC,+    PrintOperationPreviewGotPageSizeSignalInfo,+    afterPrintOperationPreviewGotPageSize   ,+    mkPrintOperationPreviewGotPageSizeCallback,+    noPrintOperationPreviewGotPageSizeCallback,+    onPrintOperationPreviewGotPageSize      ,+    printOperationPreviewGotPageSizeCallbackWrapper,+    printOperationPreviewGotPageSizeClosure ,+++-- ** Ready+    PrintOperationPreviewReadyCallback      ,+    PrintOperationPreviewReadyCallbackC     ,+    PrintOperationPreviewReadySignalInfo    ,+    afterPrintOperationPreviewReady         ,+    mkPrintOperationPreviewReadyCallback    ,+    noPrintOperationPreviewReadyCallback    ,+    onPrintOperationPreviewReady            ,+    printOperationPreviewReadyCallbackWrapper,+    printOperationPreviewReadyClosure       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface PrintOperationPreview ++newtype PrintOperationPreview = PrintOperationPreview (ForeignPtr PrintOperationPreview)+noPrintOperationPreview :: Maybe PrintOperationPreview+noPrintOperationPreview = Nothing++-- signal PrintOperationPreview::got-page-size+type PrintOperationPreviewGotPageSizeCallback =+    PrintContext ->+    PageSetup ->+    IO ()++noPrintOperationPreviewGotPageSizeCallback :: Maybe PrintOperationPreviewGotPageSizeCallback+noPrintOperationPreviewGotPageSizeCallback = Nothing++type PrintOperationPreviewGotPageSizeCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Ptr PageSetup ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationPreviewGotPageSizeCallback :: PrintOperationPreviewGotPageSizeCallbackC -> IO (FunPtr PrintOperationPreviewGotPageSizeCallbackC)++printOperationPreviewGotPageSizeClosure :: PrintOperationPreviewGotPageSizeCallback -> IO Closure+printOperationPreviewGotPageSizeClosure cb = newCClosure =<< mkPrintOperationPreviewGotPageSizeCallback wrapped+    where wrapped = printOperationPreviewGotPageSizeCallbackWrapper cb++printOperationPreviewGotPageSizeCallbackWrapper ::+    PrintOperationPreviewGotPageSizeCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Ptr PageSetup ->+    Ptr () ->+    IO ()+printOperationPreviewGotPageSizeCallbackWrapper _cb _ context page_setup _ = do+    context' <- (newObject PrintContext) context+    page_setup' <- (newObject PageSetup) page_setup+    _cb  context' page_setup'++onPrintOperationPreviewGotPageSize :: (GObject a, MonadIO m) => a -> PrintOperationPreviewGotPageSizeCallback -> m SignalHandlerId+onPrintOperationPreviewGotPageSize obj cb = liftIO $ connectPrintOperationPreviewGotPageSize obj cb SignalConnectBefore+afterPrintOperationPreviewGotPageSize :: (GObject a, MonadIO m) => a -> PrintOperationPreviewGotPageSizeCallback -> m SignalHandlerId+afterPrintOperationPreviewGotPageSize obj cb = connectPrintOperationPreviewGotPageSize obj cb SignalConnectAfter++connectPrintOperationPreviewGotPageSize :: (GObject a, MonadIO m) =>+                                           a -> PrintOperationPreviewGotPageSizeCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationPreviewGotPageSize obj cb after = liftIO $ do+    cb' <- mkPrintOperationPreviewGotPageSizeCallback (printOperationPreviewGotPageSizeCallbackWrapper cb)+    connectSignalFunPtr obj "got-page-size" cb' after++-- signal PrintOperationPreview::ready+type PrintOperationPreviewReadyCallback =+    PrintContext ->+    IO ()++noPrintOperationPreviewReadyCallback :: Maybe PrintOperationPreviewReadyCallback+noPrintOperationPreviewReadyCallback = Nothing++type PrintOperationPreviewReadyCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationPreviewReadyCallback :: PrintOperationPreviewReadyCallbackC -> IO (FunPtr PrintOperationPreviewReadyCallbackC)++printOperationPreviewReadyClosure :: PrintOperationPreviewReadyCallback -> IO Closure+printOperationPreviewReadyClosure cb = newCClosure =<< mkPrintOperationPreviewReadyCallback wrapped+    where wrapped = printOperationPreviewReadyCallbackWrapper cb++printOperationPreviewReadyCallbackWrapper ::+    PrintOperationPreviewReadyCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Ptr () ->+    IO ()+printOperationPreviewReadyCallbackWrapper _cb _ context _ = do+    context' <- (newObject PrintContext) context+    _cb  context'++onPrintOperationPreviewReady :: (GObject a, MonadIO m) => a -> PrintOperationPreviewReadyCallback -> m SignalHandlerId+onPrintOperationPreviewReady obj cb = liftIO $ connectPrintOperationPreviewReady obj cb SignalConnectBefore+afterPrintOperationPreviewReady :: (GObject a, MonadIO m) => a -> PrintOperationPreviewReadyCallback -> m SignalHandlerId+afterPrintOperationPreviewReady obj cb = connectPrintOperationPreviewReady obj cb SignalConnectAfter++connectPrintOperationPreviewReady :: (GObject a, MonadIO m) =>+                                     a -> PrintOperationPreviewReadyCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationPreviewReady obj cb after = liftIO $ do+    cb' <- mkPrintOperationPreviewReadyCallback (printOperationPreviewReadyCallbackWrapper cb)+    connectSignalFunPtr obj "ready" cb' after++type instance AttributeList PrintOperationPreview = PrintOperationPreviewAttributeList+type PrintOperationPreviewAttributeList = ('[ ] :: [(Symbol, *)])++data PrintOperationPreviewGotPageSizeSignalInfo+instance SignalInfo PrintOperationPreviewGotPageSizeSignalInfo where+    type HaskellCallbackType PrintOperationPreviewGotPageSizeSignalInfo = PrintOperationPreviewGotPageSizeCallback+    connectSignal _ = connectPrintOperationPreviewGotPageSize++data PrintOperationPreviewReadySignalInfo+instance SignalInfo PrintOperationPreviewReadySignalInfo where+    type HaskellCallbackType PrintOperationPreviewReadySignalInfo = PrintOperationPreviewReadyCallback+    connectSignal _ = connectPrintOperationPreviewReady++type instance SignalList PrintOperationPreview = PrintOperationPreviewSignalList+type PrintOperationPreviewSignalList = ('[ '("got-page-size", PrintOperationPreviewGotPageSizeSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("ready", PrintOperationPreviewReadySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_print_operation_preview_get_type"+    c_gtk_print_operation_preview_get_type :: IO GType++type instance ParentTypes PrintOperationPreview = PrintOperationPreviewParentTypes+type PrintOperationPreviewParentTypes = '[GObject.Object]++instance GObject PrintOperationPreview where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_print_operation_preview_get_type+    ++class GObject o => PrintOperationPreviewK o+instance (GObject o, IsDescendantOf PrintOperationPreview o) => PrintOperationPreviewK o++toPrintOperationPreview :: PrintOperationPreviewK o => o -> IO PrintOperationPreview+toPrintOperationPreview = unsafeCastTo PrintOperationPreview++-- method PrintOperationPreview::end_preview+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_preview_end_preview" gtk_print_operation_preview_end_preview :: +    Ptr PrintOperationPreview ->            -- _obj : TInterface "Gtk" "PrintOperationPreview"+    IO ()+++printOperationPreviewEndPreview ::+    (MonadIO m, PrintOperationPreviewK a) =>+    a ->                                    -- _obj+    m ()+printOperationPreviewEndPreview _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_preview_end_preview _obj'+    touchManagedPtr _obj+    return ()++-- method PrintOperationPreview::is_selected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_nr", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_nr", 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 "gtk_print_operation_preview_is_selected" gtk_print_operation_preview_is_selected :: +    Ptr PrintOperationPreview ->            -- _obj : TInterface "Gtk" "PrintOperationPreview"+    Int32 ->                                -- page_nr : TBasicType TInt32+    IO CInt+++printOperationPreviewIsSelected ::+    (MonadIO m, PrintOperationPreviewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_nr+    m Bool+printOperationPreviewIsSelected _obj page_nr = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_preview_is_selected _obj' page_nr+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintOperationPreview::render_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_nr", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperationPreview", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_nr", 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 "gtk_print_operation_preview_render_page" gtk_print_operation_preview_render_page :: +    Ptr PrintOperationPreview ->            -- _obj : TInterface "Gtk" "PrintOperationPreview"+    Int32 ->                                -- page_nr : TBasicType TInt32+    IO ()+++printOperationPreviewRenderPage ::+    (MonadIO m, PrintOperationPreviewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_nr+    m ()+printOperationPreviewRenderPage _obj page_nr = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_preview_render_page _obj' page_nr+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/PrintOperationPreview.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Interfaces.PrintOperationPreview where++import Prelude ()+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 PrintOperationPreview = PrintOperationPreview (ForeignPtr PrintOperationPreview)+data PrintOperationPreviewGotPageSizeSignalInfo+data PrintOperationPreviewReadySignalInfo+instance GObject PrintOperationPreview where+class GObject o => PrintOperationPreviewK o+instance (GObject o, IsDescendantOf PrintOperationPreview o) => PrintOperationPreviewK o
+ GI/Gtk/Interfaces/RecentChooser.hs view
@@ -0,0 +1,1448 @@++{- |+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.Gtk.Interfaces.RecentChooser+    ( ++-- * Exported types+    RecentChooser(..)                       ,+    noRecentChooser                         ,+    RecentChooserK                          ,+    toRecentChooser                         ,+++ -- * Methods+-- ** recentChooserAddFilter+    recentChooserAddFilter                  ,+++-- ** recentChooserGetCurrentItem+    recentChooserGetCurrentItem             ,+++-- ** recentChooserGetCurrentUri+    recentChooserGetCurrentUri              ,+++-- ** recentChooserGetFilter+    recentChooserGetFilter                  ,+++-- ** recentChooserGetItems+    recentChooserGetItems                   ,+++-- ** recentChooserGetLimit+    recentChooserGetLimit                   ,+++-- ** recentChooserGetLocalOnly+    recentChooserGetLocalOnly               ,+++-- ** recentChooserGetSelectMultiple+    recentChooserGetSelectMultiple          ,+++-- ** recentChooserGetShowIcons+    recentChooserGetShowIcons               ,+++-- ** recentChooserGetShowNotFound+    recentChooserGetShowNotFound            ,+++-- ** recentChooserGetShowPrivate+    recentChooserGetShowPrivate             ,+++-- ** recentChooserGetShowTips+    recentChooserGetShowTips                ,+++-- ** recentChooserGetSortType+    recentChooserGetSortType                ,+++-- ** recentChooserGetUris+    recentChooserGetUris                    ,+++-- ** recentChooserListFilters+    recentChooserListFilters                ,+++-- ** recentChooserRemoveFilter+    recentChooserRemoveFilter               ,+++-- ** recentChooserSelectAll+    recentChooserSelectAll                  ,+++-- ** recentChooserSelectUri+    recentChooserSelectUri                  ,+++-- ** recentChooserSetCurrentUri+    recentChooserSetCurrentUri              ,+++-- ** recentChooserSetFilter+    recentChooserSetFilter                  ,+++-- ** recentChooserSetLimit+    recentChooserSetLimit                   ,+++-- ** recentChooserSetLocalOnly+    recentChooserSetLocalOnly               ,+++-- ** recentChooserSetSelectMultiple+    recentChooserSetSelectMultiple          ,+++-- ** recentChooserSetShowIcons+    recentChooserSetShowIcons               ,+++-- ** recentChooserSetShowNotFound+    recentChooserSetShowNotFound            ,+++-- ** recentChooserSetShowPrivate+    recentChooserSetShowPrivate             ,+++-- ** recentChooserSetShowTips+    recentChooserSetShowTips                ,+++-- ** recentChooserSetSortFunc+    recentChooserSetSortFunc                ,+++-- ** recentChooserSetSortType+    recentChooserSetSortType                ,+++-- ** recentChooserUnselectAll+    recentChooserUnselectAll                ,+++-- ** recentChooserUnselectUri+    recentChooserUnselectUri                ,+++++ -- * Properties+-- ** Filter+    RecentChooserFilterPropertyInfo         ,+    constructRecentChooserFilter            ,+    getRecentChooserFilter                  ,+    setRecentChooserFilter                  ,+++-- ** Limit+    RecentChooserLimitPropertyInfo          ,+    constructRecentChooserLimit             ,+    getRecentChooserLimit                   ,+    setRecentChooserLimit                   ,+++-- ** LocalOnly+    RecentChooserLocalOnlyPropertyInfo      ,+    constructRecentChooserLocalOnly         ,+    getRecentChooserLocalOnly               ,+    setRecentChooserLocalOnly               ,+++-- ** RecentManager+    RecentChooserRecentManagerPropertyInfo  ,+    constructRecentChooserRecentManager     ,+++-- ** SelectMultiple+    RecentChooserSelectMultiplePropertyInfo ,+    constructRecentChooserSelectMultiple    ,+    getRecentChooserSelectMultiple          ,+    setRecentChooserSelectMultiple          ,+++-- ** ShowIcons+    RecentChooserShowIconsPropertyInfo      ,+    constructRecentChooserShowIcons         ,+    getRecentChooserShowIcons               ,+    setRecentChooserShowIcons               ,+++-- ** ShowNotFound+    RecentChooserShowNotFoundPropertyInfo   ,+    constructRecentChooserShowNotFound      ,+    getRecentChooserShowNotFound            ,+    setRecentChooserShowNotFound            ,+++-- ** ShowPrivate+    RecentChooserShowPrivatePropertyInfo    ,+    constructRecentChooserShowPrivate       ,+    getRecentChooserShowPrivate             ,+    setRecentChooserShowPrivate             ,+++-- ** ShowTips+    RecentChooserShowTipsPropertyInfo       ,+    constructRecentChooserShowTips          ,+    getRecentChooserShowTips                ,+    setRecentChooserShowTips                ,+++-- ** SortType+    RecentChooserSortTypePropertyInfo       ,+    constructRecentChooserSortType          ,+    getRecentChooserSortType                ,+    setRecentChooserSortType                ,+++++ -- * Signals+-- ** ItemActivated+    RecentChooserItemActivatedCallback      ,+    RecentChooserItemActivatedCallbackC     ,+    RecentChooserItemActivatedSignalInfo    ,+    afterRecentChooserItemActivated         ,+    mkRecentChooserItemActivatedCallback    ,+    noRecentChooserItemActivatedCallback    ,+    onRecentChooserItemActivated            ,+    recentChooserItemActivatedCallbackWrapper,+    recentChooserItemActivatedClosure       ,+++-- ** SelectionChanged+    RecentChooserSelectionChangedCallback   ,+    RecentChooserSelectionChangedCallbackC  ,+    RecentChooserSelectionChangedSignalInfo ,+    afterRecentChooserSelectionChanged      ,+    mkRecentChooserSelectionChangedCallback ,+    noRecentChooserSelectionChangedCallback ,+    onRecentChooserSelectionChanged         ,+    recentChooserSelectionChangedCallbackWrapper,+    recentChooserSelectionChangedClosure    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface RecentChooser ++newtype RecentChooser = RecentChooser (ForeignPtr RecentChooser)+noRecentChooser :: Maybe RecentChooser+noRecentChooser = Nothing++-- signal RecentChooser::item-activated+type RecentChooserItemActivatedCallback =+    IO ()++noRecentChooserItemActivatedCallback :: Maybe RecentChooserItemActivatedCallback+noRecentChooserItemActivatedCallback = Nothing++type RecentChooserItemActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRecentChooserItemActivatedCallback :: RecentChooserItemActivatedCallbackC -> IO (FunPtr RecentChooserItemActivatedCallbackC)++recentChooserItemActivatedClosure :: RecentChooserItemActivatedCallback -> IO Closure+recentChooserItemActivatedClosure cb = newCClosure =<< mkRecentChooserItemActivatedCallback wrapped+    where wrapped = recentChooserItemActivatedCallbackWrapper cb++recentChooserItemActivatedCallbackWrapper ::+    RecentChooserItemActivatedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+recentChooserItemActivatedCallbackWrapper _cb _ _ = do+    _cb ++onRecentChooserItemActivated :: (GObject a, MonadIO m) => a -> RecentChooserItemActivatedCallback -> m SignalHandlerId+onRecentChooserItemActivated obj cb = liftIO $ connectRecentChooserItemActivated obj cb SignalConnectBefore+afterRecentChooserItemActivated :: (GObject a, MonadIO m) => a -> RecentChooserItemActivatedCallback -> m SignalHandlerId+afterRecentChooserItemActivated obj cb = connectRecentChooserItemActivated obj cb SignalConnectAfter++connectRecentChooserItemActivated :: (GObject a, MonadIO m) =>+                                     a -> RecentChooserItemActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectRecentChooserItemActivated obj cb after = liftIO $ do+    cb' <- mkRecentChooserItemActivatedCallback (recentChooserItemActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "item-activated" cb' after++-- signal RecentChooser::selection-changed+type RecentChooserSelectionChangedCallback =+    IO ()++noRecentChooserSelectionChangedCallback :: Maybe RecentChooserSelectionChangedCallback+noRecentChooserSelectionChangedCallback = Nothing++type RecentChooserSelectionChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRecentChooserSelectionChangedCallback :: RecentChooserSelectionChangedCallbackC -> IO (FunPtr RecentChooserSelectionChangedCallbackC)++recentChooserSelectionChangedClosure :: RecentChooserSelectionChangedCallback -> IO Closure+recentChooserSelectionChangedClosure cb = newCClosure =<< mkRecentChooserSelectionChangedCallback wrapped+    where wrapped = recentChooserSelectionChangedCallbackWrapper cb++recentChooserSelectionChangedCallbackWrapper ::+    RecentChooserSelectionChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+recentChooserSelectionChangedCallbackWrapper _cb _ _ = do+    _cb ++onRecentChooserSelectionChanged :: (GObject a, MonadIO m) => a -> RecentChooserSelectionChangedCallback -> m SignalHandlerId+onRecentChooserSelectionChanged obj cb = liftIO $ connectRecentChooserSelectionChanged obj cb SignalConnectBefore+afterRecentChooserSelectionChanged :: (GObject a, MonadIO m) => a -> RecentChooserSelectionChangedCallback -> m SignalHandlerId+afterRecentChooserSelectionChanged obj cb = connectRecentChooserSelectionChanged obj cb SignalConnectAfter++connectRecentChooserSelectionChanged :: (GObject a, MonadIO m) =>+                                        a -> RecentChooserSelectionChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectRecentChooserSelectionChanged obj cb after = liftIO $ do+    cb' <- mkRecentChooserSelectionChangedCallback (recentChooserSelectionChangedCallbackWrapper cb)+    connectSignalFunPtr obj "selection-changed" cb' after++-- VVV Prop "filter"+   -- Type: TInterface "Gtk" "RecentFilter"+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserFilter :: (MonadIO m, RecentChooserK o) => o -> m RecentFilter+getRecentChooserFilter obj = liftIO $ getObjectPropertyObject obj "filter" RecentFilter++setRecentChooserFilter :: (MonadIO m, RecentChooserK o, RecentFilterK a) => o -> a -> m ()+setRecentChooserFilter obj val = liftIO $ setObjectPropertyObject obj "filter" val++constructRecentChooserFilter :: (RecentFilterK a) => a -> IO ([Char], GValue)+constructRecentChooserFilter val = constructObjectPropertyObject "filter" val++data RecentChooserFilterPropertyInfo+instance AttrInfo RecentChooserFilterPropertyInfo where+    type AttrAllowedOps RecentChooserFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserFilterPropertyInfo = RecentFilterK+    type AttrBaseTypeConstraint RecentChooserFilterPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserFilterPropertyInfo = RecentFilter+    type AttrLabel RecentChooserFilterPropertyInfo = "RecentChooser::filter"+    attrGet _ = getRecentChooserFilter+    attrSet _ = setRecentChooserFilter+    attrConstruct _ = constructRecentChooserFilter++-- VVV Prop "limit"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserLimit :: (MonadIO m, RecentChooserK o) => o -> m Int32+getRecentChooserLimit obj = liftIO $ getObjectPropertyCInt obj "limit"++setRecentChooserLimit :: (MonadIO m, RecentChooserK o) => o -> Int32 -> m ()+setRecentChooserLimit obj val = liftIO $ setObjectPropertyCInt obj "limit" val++constructRecentChooserLimit :: Int32 -> IO ([Char], GValue)+constructRecentChooserLimit val = constructObjectPropertyCInt "limit" val++data RecentChooserLimitPropertyInfo+instance AttrInfo RecentChooserLimitPropertyInfo where+    type AttrAllowedOps RecentChooserLimitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserLimitPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint RecentChooserLimitPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserLimitPropertyInfo = Int32+    type AttrLabel RecentChooserLimitPropertyInfo = "RecentChooser::limit"+    attrGet _ = getRecentChooserLimit+    attrSet _ = setRecentChooserLimit+    attrConstruct _ = constructRecentChooserLimit++-- VVV Prop "local-only"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserLocalOnly :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserLocalOnly obj = liftIO $ getObjectPropertyBool obj "local-only"++setRecentChooserLocalOnly :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserLocalOnly obj val = liftIO $ setObjectPropertyBool obj "local-only" val++constructRecentChooserLocalOnly :: Bool -> IO ([Char], GValue)+constructRecentChooserLocalOnly val = constructObjectPropertyBool "local-only" val++data RecentChooserLocalOnlyPropertyInfo+instance AttrInfo RecentChooserLocalOnlyPropertyInfo where+    type AttrAllowedOps RecentChooserLocalOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserLocalOnlyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserLocalOnlyPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserLocalOnlyPropertyInfo = Bool+    type AttrLabel RecentChooserLocalOnlyPropertyInfo = "RecentChooser::local-only"+    attrGet _ = getRecentChooserLocalOnly+    attrSet _ = setRecentChooserLocalOnly+    attrConstruct _ = constructRecentChooserLocalOnly++-- VVV Prop "recent-manager"+   -- Type: TInterface "Gtk" "RecentManager"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructRecentChooserRecentManager :: (RecentManagerK a) => a -> IO ([Char], GValue)+constructRecentChooserRecentManager val = constructObjectPropertyObject "recent-manager" val++data RecentChooserRecentManagerPropertyInfo+instance AttrInfo RecentChooserRecentManagerPropertyInfo where+    type AttrAllowedOps RecentChooserRecentManagerPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint RecentChooserRecentManagerPropertyInfo = RecentManagerK+    type AttrBaseTypeConstraint RecentChooserRecentManagerPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserRecentManagerPropertyInfo = ()+    type AttrLabel RecentChooserRecentManagerPropertyInfo = "RecentChooser::recent-manager"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructRecentChooserRecentManager++-- VVV Prop "select-multiple"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserSelectMultiple :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserSelectMultiple obj = liftIO $ getObjectPropertyBool obj "select-multiple"++setRecentChooserSelectMultiple :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserSelectMultiple obj val = liftIO $ setObjectPropertyBool obj "select-multiple" val++constructRecentChooserSelectMultiple :: Bool -> IO ([Char], GValue)+constructRecentChooserSelectMultiple val = constructObjectPropertyBool "select-multiple" val++data RecentChooserSelectMultiplePropertyInfo+instance AttrInfo RecentChooserSelectMultiplePropertyInfo where+    type AttrAllowedOps RecentChooserSelectMultiplePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserSelectMultiplePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserSelectMultiplePropertyInfo = RecentChooserK+    type AttrGetType RecentChooserSelectMultiplePropertyInfo = Bool+    type AttrLabel RecentChooserSelectMultiplePropertyInfo = "RecentChooser::select-multiple"+    attrGet _ = getRecentChooserSelectMultiple+    attrSet _ = setRecentChooserSelectMultiple+    attrConstruct _ = constructRecentChooserSelectMultiple++-- VVV Prop "show-icons"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserShowIcons :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserShowIcons obj = liftIO $ getObjectPropertyBool obj "show-icons"++setRecentChooserShowIcons :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserShowIcons obj val = liftIO $ setObjectPropertyBool obj "show-icons" val++constructRecentChooserShowIcons :: Bool -> IO ([Char], GValue)+constructRecentChooserShowIcons val = constructObjectPropertyBool "show-icons" val++data RecentChooserShowIconsPropertyInfo+instance AttrInfo RecentChooserShowIconsPropertyInfo where+    type AttrAllowedOps RecentChooserShowIconsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserShowIconsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserShowIconsPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserShowIconsPropertyInfo = Bool+    type AttrLabel RecentChooserShowIconsPropertyInfo = "RecentChooser::show-icons"+    attrGet _ = getRecentChooserShowIcons+    attrSet _ = setRecentChooserShowIcons+    attrConstruct _ = constructRecentChooserShowIcons++-- VVV Prop "show-not-found"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserShowNotFound :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserShowNotFound obj = liftIO $ getObjectPropertyBool obj "show-not-found"++setRecentChooserShowNotFound :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserShowNotFound obj val = liftIO $ setObjectPropertyBool obj "show-not-found" val++constructRecentChooserShowNotFound :: Bool -> IO ([Char], GValue)+constructRecentChooserShowNotFound val = constructObjectPropertyBool "show-not-found" val++data RecentChooserShowNotFoundPropertyInfo+instance AttrInfo RecentChooserShowNotFoundPropertyInfo where+    type AttrAllowedOps RecentChooserShowNotFoundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserShowNotFoundPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserShowNotFoundPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserShowNotFoundPropertyInfo = Bool+    type AttrLabel RecentChooserShowNotFoundPropertyInfo = "RecentChooser::show-not-found"+    attrGet _ = getRecentChooserShowNotFound+    attrSet _ = setRecentChooserShowNotFound+    attrConstruct _ = constructRecentChooserShowNotFound++-- VVV Prop "show-private"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserShowPrivate :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserShowPrivate obj = liftIO $ getObjectPropertyBool obj "show-private"++setRecentChooserShowPrivate :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserShowPrivate obj val = liftIO $ setObjectPropertyBool obj "show-private" val++constructRecentChooserShowPrivate :: Bool -> IO ([Char], GValue)+constructRecentChooserShowPrivate val = constructObjectPropertyBool "show-private" val++data RecentChooserShowPrivatePropertyInfo+instance AttrInfo RecentChooserShowPrivatePropertyInfo where+    type AttrAllowedOps RecentChooserShowPrivatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserShowPrivatePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserShowPrivatePropertyInfo = RecentChooserK+    type AttrGetType RecentChooserShowPrivatePropertyInfo = Bool+    type AttrLabel RecentChooserShowPrivatePropertyInfo = "RecentChooser::show-private"+    attrGet _ = getRecentChooserShowPrivate+    attrSet _ = setRecentChooserShowPrivate+    attrConstruct _ = constructRecentChooserShowPrivate++-- VVV Prop "show-tips"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserShowTips :: (MonadIO m, RecentChooserK o) => o -> m Bool+getRecentChooserShowTips obj = liftIO $ getObjectPropertyBool obj "show-tips"++setRecentChooserShowTips :: (MonadIO m, RecentChooserK o) => o -> Bool -> m ()+setRecentChooserShowTips obj val = liftIO $ setObjectPropertyBool obj "show-tips" val++constructRecentChooserShowTips :: Bool -> IO ([Char], GValue)+constructRecentChooserShowTips val = constructObjectPropertyBool "show-tips" val++data RecentChooserShowTipsPropertyInfo+instance AttrInfo RecentChooserShowTipsPropertyInfo where+    type AttrAllowedOps RecentChooserShowTipsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserShowTipsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentChooserShowTipsPropertyInfo = RecentChooserK+    type AttrGetType RecentChooserShowTipsPropertyInfo = Bool+    type AttrLabel RecentChooserShowTipsPropertyInfo = "RecentChooser::show-tips"+    attrGet _ = getRecentChooserShowTips+    attrSet _ = setRecentChooserShowTips+    attrConstruct _ = constructRecentChooserShowTips++-- VVV Prop "sort-type"+   -- Type: TInterface "Gtk" "RecentSortType"+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentChooserSortType :: (MonadIO m, RecentChooserK o) => o -> m RecentSortType+getRecentChooserSortType obj = liftIO $ getObjectPropertyEnum obj "sort-type"++setRecentChooserSortType :: (MonadIO m, RecentChooserK o) => o -> RecentSortType -> m ()+setRecentChooserSortType obj val = liftIO $ setObjectPropertyEnum obj "sort-type" val++constructRecentChooserSortType :: RecentSortType -> IO ([Char], GValue)+constructRecentChooserSortType val = constructObjectPropertyEnum "sort-type" val++data RecentChooserSortTypePropertyInfo+instance AttrInfo RecentChooserSortTypePropertyInfo where+    type AttrAllowedOps RecentChooserSortTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentChooserSortTypePropertyInfo = (~) RecentSortType+    type AttrBaseTypeConstraint RecentChooserSortTypePropertyInfo = RecentChooserK+    type AttrGetType RecentChooserSortTypePropertyInfo = RecentSortType+    type AttrLabel RecentChooserSortTypePropertyInfo = "RecentChooser::sort-type"+    attrGet _ = getRecentChooserSortType+    attrSet _ = setRecentChooserSortType+    attrConstruct _ = constructRecentChooserSortType++type instance AttributeList RecentChooser = RecentChooserAttributeList+type RecentChooserAttributeList = ('[ '("filter", RecentChooserFilterPropertyInfo), '("limit", RecentChooserLimitPropertyInfo), '("local-only", RecentChooserLocalOnlyPropertyInfo), '("recent-manager", RecentChooserRecentManagerPropertyInfo), '("select-multiple", RecentChooserSelectMultiplePropertyInfo), '("show-icons", RecentChooserShowIconsPropertyInfo), '("show-not-found", RecentChooserShowNotFoundPropertyInfo), '("show-private", RecentChooserShowPrivatePropertyInfo), '("show-tips", RecentChooserShowTipsPropertyInfo), '("sort-type", RecentChooserSortTypePropertyInfo)] :: [(Symbol, *)])++data RecentChooserItemActivatedSignalInfo+instance SignalInfo RecentChooserItemActivatedSignalInfo where+    type HaskellCallbackType RecentChooserItemActivatedSignalInfo = RecentChooserItemActivatedCallback+    connectSignal _ = connectRecentChooserItemActivated++data RecentChooserSelectionChangedSignalInfo+instance SignalInfo RecentChooserSelectionChangedSignalInfo where+    type HaskellCallbackType RecentChooserSelectionChangedSignalInfo = RecentChooserSelectionChangedCallback+    connectSignal _ = connectRecentChooserSelectionChanged++type instance SignalList RecentChooser = RecentChooserSignalList+type RecentChooserSignalList = ('[ '("item-activated", RecentChooserItemActivatedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("selection-changed", RecentChooserSelectionChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_recent_chooser_get_type"+    c_gtk_recent_chooser_get_type :: IO GType++type instance ParentTypes RecentChooser = RecentChooserParentTypes+type RecentChooserParentTypes = '[GObject.Object]++instance GObject RecentChooser where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_recent_chooser_get_type+    ++class GObject o => RecentChooserK o+instance (GObject o, IsDescendantOf RecentChooser o) => RecentChooserK o++toRecentChooser :: RecentChooserK o => o -> IO RecentChooser+toRecentChooser = unsafeCastTo RecentChooser++-- method RecentChooser::add_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_add_filter" gtk_recent_chooser_add_filter :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    Ptr RecentFilter ->                     -- filter : TInterface "Gtk" "RecentFilter"+    IO ()+++recentChooserAddFilter ::+    (MonadIO m, RecentChooserK a, RecentFilterK b) =>+    a ->                                    -- _obj+    b ->                                    -- filter+    m ()+recentChooserAddFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let filter' = unsafeManagedPtrCastPtr filter+    gtk_recent_chooser_add_filter _obj' filter'+    touchManagedPtr _obj+    touchManagedPtr filter+    return ()++-- method RecentChooser::get_current_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RecentInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_current_item" gtk_recent_chooser_get_current_item :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO (Ptr RecentInfo)+++recentChooserGetCurrentItem ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m RecentInfo+recentChooserGetCurrentItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_current_item _obj'+    checkUnexpectedReturnNULL "gtk_recent_chooser_get_current_item" result+    result' <- (wrapBoxed RecentInfo) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_current_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_current_uri" gtk_recent_chooser_get_current_uri :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CString+++recentChooserGetCurrentUri ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m T.Text+recentChooserGetCurrentUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_current_uri _obj'+    checkUnexpectedReturnNULL "gtk_recent_chooser_get_current_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RecentFilter"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_filter" gtk_recent_chooser_get_filter :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO (Ptr RecentFilter)+++recentChooserGetFilter ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m RecentFilter+recentChooserGetFilter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_filter _obj'+    checkUnexpectedReturnNULL "gtk_recent_chooser_get_filter" result+    result' <- (newObject RecentFilter) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_items+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "RecentInfo")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_items" gtk_recent_chooser_get_items :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO (Ptr (GList (Ptr RecentInfo)))+++recentChooserGetItems ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m [RecentInfo]+recentChooserGetItems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_items _obj'+    checkUnexpectedReturnNULL "gtk_recent_chooser_get_items" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed RecentInfo) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method RecentChooser::get_limit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_limit" gtk_recent_chooser_get_limit :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO Int32+++recentChooserGetLimit ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Int32+recentChooserGetLimit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_limit _obj'+    touchManagedPtr _obj+    return result++-- method RecentChooser::get_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_local_only" gtk_recent_chooser_get_local_only :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetLocalOnly ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetLocalOnly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_local_only _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_select_multiple+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_select_multiple" gtk_recent_chooser_get_select_multiple :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetSelectMultiple ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetSelectMultiple _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_select_multiple _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_show_icons+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_show_icons" gtk_recent_chooser_get_show_icons :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetShowIcons ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetShowIcons _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_show_icons _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_show_not_found+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_show_not_found" gtk_recent_chooser_get_show_not_found :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetShowNotFound ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetShowNotFound _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_show_not_found _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_show_private+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_show_private" gtk_recent_chooser_get_show_private :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetShowPrivate ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetShowPrivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_show_private _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_show_tips+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_show_tips" gtk_recent_chooser_get_show_tips :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CInt+++recentChooserGetShowTips ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m Bool+recentChooserGetShowTips _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_show_tips _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_sort_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RecentSortType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_get_sort_type" gtk_recent_chooser_get_sort_type :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO CUInt+++recentChooserGetSortType ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m RecentSortType+recentChooserGetSortType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_get_sort_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method RecentChooser::get_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", 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 "Gtk" "RecentChooser", 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 "gtk_recent_chooser_get_uris" gtk_recent_chooser_get_uris :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    IO (Ptr CString)+++recentChooserGetUris ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m ([T.Text],Word64)+recentChooserGetUris _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    length_ <- allocMem :: IO (Ptr Word64)+    result <- gtk_recent_chooser_get_uris _obj' length_+    checkUnexpectedReturnNULL "gtk_recent_chooser_get_uris" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    length_' <- peek length_+    touchManagedPtr _obj+    freeMem length_+    return (result', length_')++-- method RecentChooser::list_filters+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "RecentFilter")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_list_filters" gtk_recent_chooser_list_filters :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO (Ptr (GSList (Ptr RecentFilter)))+++recentChooserListFilters ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m [RecentFilter]+recentChooserListFilters _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_chooser_list_filters _obj'+    checkUnexpectedReturnNULL "gtk_recent_chooser_list_filters" result+    result' <- unpackGSList result+    result'' <- mapM (newObject RecentFilter) result'+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method RecentChooser::remove_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_remove_filter" gtk_recent_chooser_remove_filter :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    Ptr RecentFilter ->                     -- filter : TInterface "Gtk" "RecentFilter"+    IO ()+++recentChooserRemoveFilter ::+    (MonadIO m, RecentChooserK a, RecentFilterK b) =>+    a ->                                    -- _obj+    b ->                                    -- filter+    m ()+recentChooserRemoveFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let filter' = unsafeManagedPtrCastPtr filter+    gtk_recent_chooser_remove_filter _obj' filter'+    touchManagedPtr _obj+    touchManagedPtr filter+    return ()++-- method RecentChooser::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_select_all" gtk_recent_chooser_select_all :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO ()+++recentChooserSelectAll ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m ()+recentChooserSelectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_recent_chooser_select_all _obj'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::select_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", 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 "Gtk" "RecentChooser", 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 : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_recent_chooser_select_uri" gtk_recent_chooser_select_uri :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++recentChooserSelectUri ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+recentChooserSelectUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gtk_recent_chooser_select_uri _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++-- method RecentChooser::set_current_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", 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 "Gtk" "RecentChooser", 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 : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_recent_chooser_set_current_uri" gtk_recent_chooser_set_current_uri :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++recentChooserSetCurrentUri ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+recentChooserSetCurrentUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gtk_recent_chooser_set_current_uri _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++-- method RecentChooser::set_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter", argType = TInterface "Gtk" "RecentFilter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_set_filter" gtk_recent_chooser_set_filter :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    Ptr RecentFilter ->                     -- filter : TInterface "Gtk" "RecentFilter"+    IO ()+++recentChooserSetFilter ::+    (MonadIO m, RecentChooserK a, RecentFilterK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- filter+    m ()+recentChooserSetFilter _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrCastPtr jFilter+            return jFilter'+    gtk_recent_chooser_set_filter _obj' maybeFilter+    touchManagedPtr _obj+    whenJust filter touchManagedPtr+    return ()++-- method RecentChooser::set_limit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "limit", 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 "gtk_recent_chooser_set_limit" gtk_recent_chooser_set_limit :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    Int32 ->                                -- limit : TBasicType TInt32+    IO ()+++recentChooserSetLimit ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- limit+    m ()+recentChooserSetLimit _obj limit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_recent_chooser_set_limit _obj' limit+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_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 "gtk_recent_chooser_set_local_only" gtk_recent_chooser_set_local_only :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- local_only : TBasicType TBoolean+    IO ()+++recentChooserSetLocalOnly ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- local_only+    m ()+recentChooserSetLocalOnly _obj local_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let local_only' = (fromIntegral . fromEnum) local_only+    gtk_recent_chooser_set_local_only _obj' local_only'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_select_multiple+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "select_multiple", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "select_multiple", 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 "gtk_recent_chooser_set_select_multiple" gtk_recent_chooser_set_select_multiple :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- select_multiple : TBasicType TBoolean+    IO ()+++recentChooserSetSelectMultiple ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- select_multiple+    m ()+recentChooserSetSelectMultiple _obj select_multiple = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let select_multiple' = (fromIntegral . fromEnum) select_multiple+    gtk_recent_chooser_set_select_multiple _obj' select_multiple'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_show_icons+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_icons", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_icons", 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 "gtk_recent_chooser_set_show_icons" gtk_recent_chooser_set_show_icons :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- show_icons : TBasicType TBoolean+    IO ()+++recentChooserSetShowIcons ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_icons+    m ()+recentChooserSetShowIcons _obj show_icons = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_icons' = (fromIntegral . fromEnum) show_icons+    gtk_recent_chooser_set_show_icons _obj' show_icons'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_show_not_found+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_not_found", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_not_found", 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 "gtk_recent_chooser_set_show_not_found" gtk_recent_chooser_set_show_not_found :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- show_not_found : TBasicType TBoolean+    IO ()+++recentChooserSetShowNotFound ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_not_found+    m ()+recentChooserSetShowNotFound _obj show_not_found = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_not_found' = (fromIntegral . fromEnum) show_not_found+    gtk_recent_chooser_set_show_not_found _obj' show_not_found'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_show_private+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_private", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_private", 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 "gtk_recent_chooser_set_show_private" gtk_recent_chooser_set_show_private :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- show_private : TBasicType TBoolean+    IO ()+++recentChooserSetShowPrivate ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_private+    m ()+recentChooserSetShowPrivate _obj show_private = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_private' = (fromIntegral . fromEnum) show_private+    gtk_recent_chooser_set_show_private _obj' show_private'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_show_tips+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_tips", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_tips", 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 "gtk_recent_chooser_set_show_tips" gtk_recent_chooser_set_show_tips :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CInt ->                                 -- show_tips : TBasicType TBoolean+    IO ()+++recentChooserSetShowTips ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_tips+    m ()+recentChooserSetShowTips _obj show_tips = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_tips' = (fromIntegral . fromEnum) show_tips+    gtk_recent_chooser_set_show_tips _obj' show_tips'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "RecentSortFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "sort_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "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 "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "RecentSortFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_set_sort_func" gtk_recent_chooser_set_sort_func :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    FunPtr RecentSortFuncC ->               -- sort_func : TInterface "Gtk" "RecentSortFunc"+    Ptr () ->                               -- sort_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- data_destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++recentChooserSetSortFunc ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    RecentSortFunc ->                       -- sort_func+    m ()+recentChooserSetSortFunc _obj sort_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    sort_func' <- mkRecentSortFunc (recentSortFuncWrapper Nothing sort_func)+    let sort_data = castFunPtrToPtr sort_func'+    let data_destroy = safeFreeFunPtrPtr+    gtk_recent_chooser_set_sort_func _obj' sort_func' sort_data data_destroy+    touchManagedPtr _obj+    return ()++-- method RecentChooser::set_sort_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_type", argType = TInterface "Gtk" "RecentSortType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_type", argType = TInterface "Gtk" "RecentSortType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_set_sort_type" gtk_recent_chooser_set_sort_type :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CUInt ->                                -- sort_type : TInterface "Gtk" "RecentSortType"+    IO ()+++recentChooserSetSortType ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    RecentSortType ->                       -- sort_type+    m ()+recentChooserSetSortType _obj sort_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sort_type' = (fromIntegral . fromEnum) sort_type+    gtk_recent_chooser_set_sort_type _obj' sort_type'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_unselect_all" gtk_recent_chooser_unselect_all :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    IO ()+++recentChooserUnselectAll ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    m ()+recentChooserUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_recent_chooser_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method RecentChooser::unselect_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentChooser", 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 "Gtk" "RecentChooser", 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_chooser_unselect_uri" gtk_recent_chooser_unselect_uri :: +    Ptr RecentChooser ->                    -- _obj : TInterface "Gtk" "RecentChooser"+    CString ->                              -- uri : TBasicType TUTF8+    IO ()+++recentChooserUnselectUri ::+    (MonadIO m, RecentChooserK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+recentChooserUnselectUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    gtk_recent_chooser_unselect_uri _obj' uri'+    touchManagedPtr _obj+    freeMem uri'+    return ()++
+ GI/Gtk/Interfaces/RecentChooser.hs-boot view
@@ -0,0 +1,25 @@+module GI.Gtk.Interfaces.RecentChooser where++import Prelude ()+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 RecentChooser = RecentChooser (ForeignPtr RecentChooser)+data RecentChooserFilterPropertyInfo+data RecentChooserLimitPropertyInfo+data RecentChooserLocalOnlyPropertyInfo+data RecentChooserRecentManagerPropertyInfo+data RecentChooserSelectMultiplePropertyInfo+data RecentChooserShowIconsPropertyInfo+data RecentChooserShowNotFoundPropertyInfo+data RecentChooserShowPrivatePropertyInfo+data RecentChooserShowTipsPropertyInfo+data RecentChooserSortTypePropertyInfo+data RecentChooserItemActivatedSignalInfo+data RecentChooserSelectionChangedSignalInfo+instance GObject RecentChooser where+class GObject o => RecentChooserK o+instance (GObject o, IsDescendantOf RecentChooser o) => RecentChooserK o
+ GI/Gtk/Interfaces/Scrollable.hs view
@@ -0,0 +1,475 @@++{- |+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.Gtk.Interfaces.Scrollable+    ( ++-- * Exported types+    Scrollable(..)                          ,+    noScrollable                            ,+    ScrollableK                             ,+    toScrollable                            ,+++ -- * Methods+-- ** scrollableGetBorder+    scrollableGetBorder                     ,+++-- ** scrollableGetHadjustment+    scrollableGetHadjustment                ,+++-- ** scrollableGetHscrollPolicy+    scrollableGetHscrollPolicy              ,+++-- ** scrollableGetVadjustment+    scrollableGetVadjustment                ,+++-- ** scrollableGetVscrollPolicy+    scrollableGetVscrollPolicy              ,+++-- ** scrollableSetHadjustment+    scrollableSetHadjustment                ,+++-- ** scrollableSetHscrollPolicy+    scrollableSetHscrollPolicy              ,+++-- ** scrollableSetVadjustment+    scrollableSetVadjustment                ,+++-- ** scrollableSetVscrollPolicy+    scrollableSetVscrollPolicy              ,+++++ -- * Properties+-- ** Hadjustment+    ScrollableHadjustmentPropertyInfo       ,+    constructScrollableHadjustment          ,+    getScrollableHadjustment                ,+    setScrollableHadjustment                ,+++-- ** HscrollPolicy+    ScrollableHscrollPolicyPropertyInfo     ,+    constructScrollableHscrollPolicy        ,+    getScrollableHscrollPolicy              ,+    setScrollableHscrollPolicy              ,+++-- ** Vadjustment+    ScrollableVadjustmentPropertyInfo       ,+    constructScrollableVadjustment          ,+    getScrollableVadjustment                ,+    setScrollableVadjustment                ,+++-- ** VscrollPolicy+    ScrollableVscrollPolicyPropertyInfo     ,+    constructScrollableVscrollPolicy        ,+    getScrollableVscrollPolicy              ,+    setScrollableVscrollPolicy              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface Scrollable ++newtype Scrollable = Scrollable (ForeignPtr Scrollable)+noScrollable :: Maybe Scrollable+noScrollable = Nothing++-- VVV Prop "hadjustment"+   -- Type: TInterface "Gtk" "Adjustment"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getScrollableHadjustment :: (MonadIO m, ScrollableK o) => o -> m Adjustment+getScrollableHadjustment obj = liftIO $ getObjectPropertyObject obj "hadjustment" Adjustment++setScrollableHadjustment :: (MonadIO m, ScrollableK o, AdjustmentK a) => o -> a -> m ()+setScrollableHadjustment obj val = liftIO $ setObjectPropertyObject obj "hadjustment" val++constructScrollableHadjustment :: (AdjustmentK a) => a -> IO ([Char], GValue)+constructScrollableHadjustment val = constructObjectPropertyObject "hadjustment" val++data ScrollableHadjustmentPropertyInfo+instance AttrInfo ScrollableHadjustmentPropertyInfo where+    type AttrAllowedOps ScrollableHadjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ScrollableHadjustmentPropertyInfo = AdjustmentK+    type AttrBaseTypeConstraint ScrollableHadjustmentPropertyInfo = ScrollableK+    type AttrGetType ScrollableHadjustmentPropertyInfo = Adjustment+    type AttrLabel ScrollableHadjustmentPropertyInfo = "Scrollable::hadjustment"+    attrGet _ = getScrollableHadjustment+    attrSet _ = setScrollableHadjustment+    attrConstruct _ = constructScrollableHadjustment++-- VVV Prop "hscroll-policy"+   -- Type: TInterface "Gtk" "ScrollablePolicy"+   -- Flags: [PropertyReadable,PropertyWritable]++getScrollableHscrollPolicy :: (MonadIO m, ScrollableK o) => o -> m ScrollablePolicy+getScrollableHscrollPolicy obj = liftIO $ getObjectPropertyEnum obj "hscroll-policy"++setScrollableHscrollPolicy :: (MonadIO m, ScrollableK o) => o -> ScrollablePolicy -> m ()+setScrollableHscrollPolicy obj val = liftIO $ setObjectPropertyEnum obj "hscroll-policy" val++constructScrollableHscrollPolicy :: ScrollablePolicy -> IO ([Char], GValue)+constructScrollableHscrollPolicy val = constructObjectPropertyEnum "hscroll-policy" val++data ScrollableHscrollPolicyPropertyInfo+instance AttrInfo ScrollableHscrollPolicyPropertyInfo where+    type AttrAllowedOps ScrollableHscrollPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ScrollableHscrollPolicyPropertyInfo = (~) ScrollablePolicy+    type AttrBaseTypeConstraint ScrollableHscrollPolicyPropertyInfo = ScrollableK+    type AttrGetType ScrollableHscrollPolicyPropertyInfo = ScrollablePolicy+    type AttrLabel ScrollableHscrollPolicyPropertyInfo = "Scrollable::hscroll-policy"+    attrGet _ = getScrollableHscrollPolicy+    attrSet _ = setScrollableHscrollPolicy+    attrConstruct _ = constructScrollableHscrollPolicy++-- VVV Prop "vadjustment"+   -- Type: TInterface "Gtk" "Adjustment"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getScrollableVadjustment :: (MonadIO m, ScrollableK o) => o -> m Adjustment+getScrollableVadjustment obj = liftIO $ getObjectPropertyObject obj "vadjustment" Adjustment++setScrollableVadjustment :: (MonadIO m, ScrollableK o, AdjustmentK a) => o -> a -> m ()+setScrollableVadjustment obj val = liftIO $ setObjectPropertyObject obj "vadjustment" val++constructScrollableVadjustment :: (AdjustmentK a) => a -> IO ([Char], GValue)+constructScrollableVadjustment val = constructObjectPropertyObject "vadjustment" val++data ScrollableVadjustmentPropertyInfo+instance AttrInfo ScrollableVadjustmentPropertyInfo where+    type AttrAllowedOps ScrollableVadjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ScrollableVadjustmentPropertyInfo = AdjustmentK+    type AttrBaseTypeConstraint ScrollableVadjustmentPropertyInfo = ScrollableK+    type AttrGetType ScrollableVadjustmentPropertyInfo = Adjustment+    type AttrLabel ScrollableVadjustmentPropertyInfo = "Scrollable::vadjustment"+    attrGet _ = getScrollableVadjustment+    attrSet _ = setScrollableVadjustment+    attrConstruct _ = constructScrollableVadjustment++-- VVV Prop "vscroll-policy"+   -- Type: TInterface "Gtk" "ScrollablePolicy"+   -- Flags: [PropertyReadable,PropertyWritable]++getScrollableVscrollPolicy :: (MonadIO m, ScrollableK o) => o -> m ScrollablePolicy+getScrollableVscrollPolicy obj = liftIO $ getObjectPropertyEnum obj "vscroll-policy"++setScrollableVscrollPolicy :: (MonadIO m, ScrollableK o) => o -> ScrollablePolicy -> m ()+setScrollableVscrollPolicy obj val = liftIO $ setObjectPropertyEnum obj "vscroll-policy" val++constructScrollableVscrollPolicy :: ScrollablePolicy -> IO ([Char], GValue)+constructScrollableVscrollPolicy val = constructObjectPropertyEnum "vscroll-policy" val++data ScrollableVscrollPolicyPropertyInfo+instance AttrInfo ScrollableVscrollPolicyPropertyInfo where+    type AttrAllowedOps ScrollableVscrollPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ScrollableVscrollPolicyPropertyInfo = (~) ScrollablePolicy+    type AttrBaseTypeConstraint ScrollableVscrollPolicyPropertyInfo = ScrollableK+    type AttrGetType ScrollableVscrollPolicyPropertyInfo = ScrollablePolicy+    type AttrLabel ScrollableVscrollPolicyPropertyInfo = "Scrollable::vscroll-policy"+    attrGet _ = getScrollableVscrollPolicy+    attrSet _ = setScrollableVscrollPolicy+    attrConstruct _ = constructScrollableVscrollPolicy++type instance AttributeList Scrollable = ScrollableAttributeList+type ScrollableAttributeList = ('[ '("hadjustment", ScrollableHadjustmentPropertyInfo), '("hscroll-policy", ScrollableHscrollPolicyPropertyInfo), '("vadjustment", ScrollableVadjustmentPropertyInfo), '("vscroll-policy", ScrollableVscrollPolicyPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Scrollable = ScrollableSignalList+type ScrollableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_scrollable_get_type"+    c_gtk_scrollable_get_type :: IO GType++type instance ParentTypes Scrollable = ScrollableParentTypes+type ScrollableParentTypes = '[GObject.Object]++instance GObject Scrollable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_scrollable_get_type+    ++class GObject o => ScrollableK o+instance (GObject o, IsDescendantOf Scrollable o) => ScrollableK o++toScrollable :: ScrollableK o => o -> IO Scrollable+toScrollable = unsafeCastTo Scrollable++-- method Scrollable::get_border+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border", argType = TInterface "Gtk" "Border", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border", argType = TInterface "Gtk" "Border", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_get_border" gtk_scrollable_get_border :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    Ptr Border ->                           -- border : TInterface "Gtk" "Border"+    IO CInt+++scrollableGetBorder ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    Border ->                               -- border+    m Bool+scrollableGetBorder _obj border = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let border' = unsafeManagedPtrGetPtr border+    result <- gtk_scrollable_get_border _obj' border'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr border+    return result'++-- method Scrollable::get_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_get_hadjustment" gtk_scrollable_get_hadjustment :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    IO (Ptr Adjustment)+++scrollableGetHadjustment ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    m Adjustment+scrollableGetHadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_scrollable_get_hadjustment _obj'+    checkUnexpectedReturnNULL "gtk_scrollable_get_hadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Scrollable::get_hscroll_policy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ScrollablePolicy"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_get_hscroll_policy" gtk_scrollable_get_hscroll_policy :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    IO CUInt+++scrollableGetHscrollPolicy ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    m ScrollablePolicy+scrollableGetHscrollPolicy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_scrollable_get_hscroll_policy _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Scrollable::get_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_get_vadjustment" gtk_scrollable_get_vadjustment :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    IO (Ptr Adjustment)+++scrollableGetVadjustment ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    m Adjustment+scrollableGetVadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_scrollable_get_vadjustment _obj'+    checkUnexpectedReturnNULL "gtk_scrollable_get_vadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Scrollable::get_vscroll_policy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ScrollablePolicy"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_get_vscroll_policy" gtk_scrollable_get_vscroll_policy :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    IO CUInt+++scrollableGetVscrollPolicy ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    m ScrollablePolicy+scrollableGetVscrollPolicy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_scrollable_get_vscroll_policy _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Scrollable::set_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_set_hadjustment" gtk_scrollable_set_hadjustment :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    Ptr Adjustment ->                       -- hadjustment : TInterface "Gtk" "Adjustment"+    IO ()+++scrollableSetHadjustment ::+    (MonadIO m, ScrollableK a, AdjustmentK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- hadjustment+    m ()+scrollableSetHadjustment _obj hadjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeHadjustment <- case hadjustment of+        Nothing -> return nullPtr+        Just jHadjustment -> do+            let jHadjustment' = unsafeManagedPtrCastPtr jHadjustment+            return jHadjustment'+    gtk_scrollable_set_hadjustment _obj' maybeHadjustment+    touchManagedPtr _obj+    whenJust hadjustment touchManagedPtr+    return ()++-- method Scrollable::set_hscroll_policy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "policy", argType = TInterface "Gtk" "ScrollablePolicy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "policy", argType = TInterface "Gtk" "ScrollablePolicy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_set_hscroll_policy" gtk_scrollable_set_hscroll_policy :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    CUInt ->                                -- policy : TInterface "Gtk" "ScrollablePolicy"+    IO ()+++scrollableSetHscrollPolicy ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    ScrollablePolicy ->                     -- policy+    m ()+scrollableSetHscrollPolicy _obj policy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let policy' = (fromIntegral . fromEnum) policy+    gtk_scrollable_set_hscroll_policy _obj' policy'+    touchManagedPtr _obj+    return ()++-- method Scrollable::set_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_set_vadjustment" gtk_scrollable_set_vadjustment :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    Ptr Adjustment ->                       -- vadjustment : TInterface "Gtk" "Adjustment"+    IO ()+++scrollableSetVadjustment ::+    (MonadIO m, ScrollableK a, AdjustmentK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- vadjustment+    m ()+scrollableSetVadjustment _obj vadjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeVadjustment <- case vadjustment of+        Nothing -> return nullPtr+        Just jVadjustment -> do+            let jVadjustment' = unsafeManagedPtrCastPtr jVadjustment+            return jVadjustment'+    gtk_scrollable_set_vadjustment _obj' maybeVadjustment+    touchManagedPtr _obj+    whenJust vadjustment touchManagedPtr+    return ()++-- method Scrollable::set_vscroll_policy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "policy", argType = TInterface "Gtk" "ScrollablePolicy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Scrollable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "policy", argType = TInterface "Gtk" "ScrollablePolicy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_scrollable_set_vscroll_policy" gtk_scrollable_set_vscroll_policy :: +    Ptr Scrollable ->                       -- _obj : TInterface "Gtk" "Scrollable"+    CUInt ->                                -- policy : TInterface "Gtk" "ScrollablePolicy"+    IO ()+++scrollableSetVscrollPolicy ::+    (MonadIO m, ScrollableK a) =>+    a ->                                    -- _obj+    ScrollablePolicy ->                     -- policy+    m ()+scrollableSetVscrollPolicy _obj policy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let policy' = (fromIntegral . fromEnum) policy+    gtk_scrollable_set_vscroll_policy _obj' policy'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/Scrollable.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Interfaces.Scrollable where++import Prelude ()+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 Scrollable = Scrollable (ForeignPtr Scrollable)+data ScrollableHadjustmentPropertyInfo+data ScrollableHscrollPolicyPropertyInfo+data ScrollableVadjustmentPropertyInfo+data ScrollableVscrollPolicyPropertyInfo+instance GObject Scrollable where+class GObject o => ScrollableK o+instance (GObject o, IsDescendantOf Scrollable o) => ScrollableK o
+ GI/Gtk/Interfaces/StyleProvider.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.Gtk.Interfaces.StyleProvider+    ( ++-- * Exported types+    StyleProvider(..)                       ,+    noStyleProvider                         ,+    StyleProviderK                          ,+++ -- * Methods+-- ** styleProviderGetIconFactory+    styleProviderGetIconFactory             ,+++-- ** styleProviderGetStyle+    styleProviderGetStyle                   ,+++-- ** styleProviderGetStyleProperty+    styleProviderGetStyleProperty           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++-- interface StyleProvider ++newtype StyleProvider = StyleProvider (ForeignPtr StyleProvider)+noStyleProvider :: Maybe StyleProvider+noStyleProvider = Nothing++type instance AttributeList StyleProvider = StyleProviderAttributeList+type StyleProviderAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList StyleProvider = StyleProviderSignalList+type StyleProviderSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => StyleProviderK a+instance (ForeignPtrNewtype o, IsDescendantOf StyleProvider o) => StyleProviderK o+type instance ParentTypes StyleProvider = StyleProviderParentTypes+type StyleProviderParentTypes = '[]++-- method StyleProvider::get_icon_factory+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_style_provider_get_icon_factory" gtk_style_provider_get_icon_factory :: +    Ptr StyleProvider ->                    -- _obj : TInterface "Gtk" "StyleProvider"+    Ptr WidgetPath ->                       -- path : TInterface "Gtk" "WidgetPath"+    IO (Ptr IconFactory)++{-# DEPRECATED styleProviderGetIconFactory ["(Since version 3.8)","Will always return %NULL for all GTK-provided style providers."]#-}+styleProviderGetIconFactory ::+    (MonadIO m, StyleProviderK a) =>+    a ->                                    -- _obj+    WidgetPath ->                           -- path+    m IconFactory+styleProviderGetIconFactory _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_style_provider_get_icon_factory _obj' path'+    checkUnexpectedReturnNULL "gtk_style_provider_get_icon_factory" result+    result' <- (newObject IconFactory) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++-- method StyleProvider::get_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "StyleProperties"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_style_provider_get_style" gtk_style_provider_get_style :: +    Ptr StyleProvider ->                    -- _obj : TInterface "Gtk" "StyleProvider"+    Ptr WidgetPath ->                       -- path : TInterface "Gtk" "WidgetPath"+    IO (Ptr StyleProperties)++{-# DEPRECATED styleProviderGetStyle ["(Since version 3.8)","Will always return %NULL for all GTK-provided style providers","    as the interface cannot correctly work the way CSS is specified."]#-}+styleProviderGetStyle ::+    (MonadIO m, StyleProviderK a) =>+    a ->                                    -- _obj+    WidgetPath ->                           -- path+    m StyleProperties+styleProviderGetStyle _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_style_provider_get_style _obj' path'+    checkUnexpectedReturnNULL "gtk_style_provider_get_style" result+    result' <- (wrapObject StyleProperties) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++-- method StyleProvider::get_style_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "StateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "StyleProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "WidgetPath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "StateFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_style_provider_get_style_property" gtk_style_provider_get_style_property :: +    Ptr StyleProvider ->                    -- _obj : TInterface "Gtk" "StyleProvider"+    Ptr WidgetPath ->                       -- path : TInterface "Gtk" "WidgetPath"+    CUInt ->                                -- state : TInterface "Gtk" "StateFlags"+    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO CInt+++styleProviderGetStyleProperty ::+    (MonadIO m, StyleProviderK a) =>+    a ->                                    -- _obj+    WidgetPath ->                           -- path+    [StateFlags] ->                         -- state+    GParamSpec ->                           -- pspec+    m (Bool,GValue)+styleProviderGetStyleProperty _obj path state pspec = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let state' = gflagsToWord state+    let pspec' = unsafeManagedPtrGetPtr pspec+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    result <- gtk_style_provider_get_style_property _obj' path' state' pspec' value+    let result' = (/= 0) result+    value' <- (wrapBoxed GValue) value+    touchManagedPtr _obj+    touchManagedPtr path+    return (result', value')++
+ GI/Gtk/Interfaces/StyleProvider.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gtk.Interfaces.StyleProvider where++import Prelude ()+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 StyleProvider = StyleProvider (ForeignPtr StyleProvider)+class ForeignPtrNewtype a => StyleProviderK a+instance (ForeignPtrNewtype o, IsDescendantOf StyleProvider o) => StyleProviderK o
+ GI/Gtk/Interfaces/ToolShell.hs view
@@ -0,0 +1,324 @@++{- |+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.Gtk.Interfaces.ToolShell+    ( ++-- * Exported types+    ToolShell(..)                           ,+    noToolShell                             ,+    ToolShellK                              ,+    toToolShell                             ,+++ -- * Methods+-- ** toolShellGetEllipsizeMode+    toolShellGetEllipsizeMode               ,+++-- ** toolShellGetIconSize+    toolShellGetIconSize                    ,+++-- ** toolShellGetOrientation+    toolShellGetOrientation                 ,+++-- ** toolShellGetReliefStyle+    toolShellGetReliefStyle                 ,+++-- ** toolShellGetStyle+    toolShellGetStyle                       ,+++-- ** toolShellGetTextAlignment+    toolShellGetTextAlignment               ,+++-- ** toolShellGetTextOrientation+    toolShellGetTextOrientation             ,+++-- ** toolShellGetTextSizeGroup+    toolShellGetTextSizeGroup               ,+++-- ** toolShellRebuildMenu+    toolShellRebuildMenu                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango++-- interface ToolShell ++newtype ToolShell = ToolShell (ForeignPtr ToolShell)+noToolShell :: Maybe ToolShell+noToolShell = Nothing++type instance AttributeList ToolShell = ToolShellAttributeList+type ToolShellAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ToolShell = ToolShellSignalList+type ToolShellSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_tool_shell_get_type"+    c_gtk_tool_shell_get_type :: IO GType++type instance ParentTypes ToolShell = ToolShellParentTypes+type ToolShellParentTypes = '[Widget, GObject.Object]++instance GObject ToolShell where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_tool_shell_get_type+    ++class GObject o => ToolShellK o+instance (GObject o, IsDescendantOf ToolShell o) => ToolShellK o++toToolShell :: ToolShellK o => o -> IO ToolShell+toToolShell = unsafeCastTo ToolShell++-- method ToolShell::get_ellipsize_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "EllipsizeMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_ellipsize_mode" gtk_tool_shell_get_ellipsize_mode :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CUInt+++toolShellGetEllipsizeMode ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m Pango.EllipsizeMode+toolShellGetEllipsizeMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_ellipsize_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_icon_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_icon_size" gtk_tool_shell_get_icon_size :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO Int32+++toolShellGetIconSize ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m Int32+toolShellGetIconSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_icon_size _obj'+    touchManagedPtr _obj+    return result++-- method ToolShell::get_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Orientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_orientation" gtk_tool_shell_get_orientation :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CUInt+++toolShellGetOrientation ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m Orientation+toolShellGetOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_relief_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ReliefStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_relief_style" gtk_tool_shell_get_relief_style :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CUInt+++toolShellGetReliefStyle ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m ReliefStyle+toolShellGetReliefStyle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_relief_style _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ToolbarStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_style" gtk_tool_shell_get_style :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CUInt+++toolShellGetStyle ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m ToolbarStyle+toolShellGetStyle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_style _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_text_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_text_alignment" gtk_tool_shell_get_text_alignment :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CFloat+++toolShellGetTextAlignment ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m Float+toolShellGetTextAlignment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_text_alignment _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_text_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Orientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_text_orientation" gtk_tool_shell_get_text_orientation :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO CUInt+++toolShellGetTextOrientation ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m Orientation+toolShellGetTextOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_text_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::get_text_size_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SizeGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_get_text_size_group" gtk_tool_shell_get_text_size_group :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO (Ptr SizeGroup)+++toolShellGetTextSizeGroup ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m SizeGroup+toolShellGetTextSizeGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tool_shell_get_text_size_group _obj'+    checkUnexpectedReturnNULL "gtk_tool_shell_get_text_size_group" result+    result' <- (newObject SizeGroup) result+    touchManagedPtr _obj+    return result'++-- method ToolShell::rebuild_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ToolShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tool_shell_rebuild_menu" gtk_tool_shell_rebuild_menu :: +    Ptr ToolShell ->                        -- _obj : TInterface "Gtk" "ToolShell"+    IO ()+++toolShellRebuildMenu ::+    (MonadIO m, ToolShellK a) =>+    a ->                                    -- _obj+    m ()+toolShellRebuildMenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_tool_shell_rebuild_menu _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/ToolShell.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Interfaces.ToolShell where++import Prelude ()+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 ToolShell = ToolShell (ForeignPtr ToolShell)+instance GObject ToolShell where+class GObject o => ToolShellK o+instance (GObject o, IsDescendantOf ToolShell o) => ToolShellK o
+ GI/Gtk/Interfaces/TreeDragDest.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.Gtk.Interfaces.TreeDragDest+    ( ++-- * Exported types+    TreeDragDest(..)                        ,+    noTreeDragDest                          ,+    TreeDragDestK                           ,+++ -- * Methods+-- ** treeDragDestDragDataReceived+    treeDragDestDragDataReceived            ,+++-- ** treeDragDestRowDropPossible+    treeDragDestRowDropPossible             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++-- interface TreeDragDest ++newtype TreeDragDest = TreeDragDest (ForeignPtr TreeDragDest)+noTreeDragDest :: Maybe TreeDragDest+noTreeDragDest = Nothing++type instance AttributeList TreeDragDest = TreeDragDestAttributeList+type TreeDragDestAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList TreeDragDest = TreeDragDestSignalList+type TreeDragDestSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => TreeDragDestK a+instance (ForeignPtrNewtype o, IsDescendantOf TreeDragDest o) => TreeDragDestK o+type instance ParentTypes TreeDragDest = TreeDragDestParentTypes+type TreeDragDestParentTypes = '[]++-- method TreeDragDest::drag_data_received+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragDest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragDest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_drag_dest_drag_data_received" gtk_tree_drag_dest_drag_data_received :: +    Ptr TreeDragDest ->                     -- _obj : TInterface "Gtk" "TreeDragDest"+    Ptr TreePath ->                         -- dest : TInterface "Gtk" "TreePath"+    Ptr SelectionData ->                    -- selection_data : TInterface "Gtk" "SelectionData"+    IO CInt+++treeDragDestDragDataReceived ::+    (MonadIO m, TreeDragDestK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- dest+    SelectionData ->                        -- selection_data+    m Bool+treeDragDestDragDataReceived _obj dest selection_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest' = unsafeManagedPtrGetPtr dest+    let selection_data' = unsafeManagedPtrGetPtr selection_data+    result <- gtk_tree_drag_dest_drag_data_received _obj' dest' selection_data'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    touchManagedPtr selection_data+    return result'++-- method TreeDragDest::row_drop_possible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragDest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragDest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dest_path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_drag_dest_row_drop_possible" gtk_tree_drag_dest_row_drop_possible :: +    Ptr TreeDragDest ->                     -- _obj : TInterface "Gtk" "TreeDragDest"+    Ptr TreePath ->                         -- dest_path : TInterface "Gtk" "TreePath"+    Ptr SelectionData ->                    -- selection_data : TInterface "Gtk" "SelectionData"+    IO CInt+++treeDragDestRowDropPossible ::+    (MonadIO m, TreeDragDestK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- dest_path+    SelectionData ->                        -- selection_data+    m Bool+treeDragDestRowDropPossible _obj dest_path selection_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest_path' = unsafeManagedPtrGetPtr dest_path+    let selection_data' = unsafeManagedPtrGetPtr selection_data+    result <- gtk_tree_drag_dest_row_drop_possible _obj' dest_path' selection_data'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest_path+    touchManagedPtr selection_data+    return result'++
+ GI/Gtk/Interfaces/TreeDragDest.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gtk.Interfaces.TreeDragDest where++import Prelude ()+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 TreeDragDest = TreeDragDest (ForeignPtr TreeDragDest)+class ForeignPtrNewtype a => TreeDragDestK a+instance (ForeignPtrNewtype o, IsDescendantOf TreeDragDest o) => TreeDragDestK o
+ GI/Gtk/Interfaces/TreeDragSource.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.Gtk.Interfaces.TreeDragSource+    ( ++-- * Exported types+    TreeDragSource(..)                      ,+    noTreeDragSource                        ,+    TreeDragSourceK                         ,+++ -- * Methods+-- ** treeDragSourceDragDataDelete+    treeDragSourceDragDataDelete            ,+++-- ** treeDragSourceDragDataGet+    treeDragSourceDragDataGet               ,+++-- ** treeDragSourceRowDraggable+    treeDragSourceRowDraggable              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++-- interface TreeDragSource ++newtype TreeDragSource = TreeDragSource (ForeignPtr TreeDragSource)+noTreeDragSource :: Maybe TreeDragSource+noTreeDragSource = Nothing++type instance AttributeList TreeDragSource = TreeDragSourceAttributeList+type TreeDragSourceAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList TreeDragSource = TreeDragSourceSignalList+type TreeDragSourceSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => TreeDragSourceK a+instance (ForeignPtrNewtype o, IsDescendantOf TreeDragSource o) => TreeDragSourceK o+type instance ParentTypes TreeDragSource = TreeDragSourceParentTypes+type TreeDragSourceParentTypes = '[]++-- method TreeDragSource::drag_data_delete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_drag_source_drag_data_delete" gtk_tree_drag_source_drag_data_delete :: +    Ptr TreeDragSource ->                   -- _obj : TInterface "Gtk" "TreeDragSource"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO CInt+++treeDragSourceDragDataDelete ::+    (MonadIO m, TreeDragSourceK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Bool+treeDragSourceDragDataDelete _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_tree_drag_source_drag_data_delete _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++-- method TreeDragSource::drag_data_get+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection_data", argType = TInterface "Gtk" "SelectionData", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_drag_source_drag_data_get" gtk_tree_drag_source_drag_data_get :: +    Ptr TreeDragSource ->                   -- _obj : TInterface "Gtk" "TreeDragSource"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr SelectionData ->                    -- selection_data : TInterface "Gtk" "SelectionData"+    IO CInt+++treeDragSourceDragDataGet ::+    (MonadIO m, TreeDragSourceK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    SelectionData ->                        -- selection_data+    m Bool+treeDragSourceDragDataGet _obj path selection_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let selection_data' = unsafeManagedPtrGetPtr selection_data+    result <- gtk_tree_drag_source_drag_data_get _obj' path' selection_data'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr path+    touchManagedPtr selection_data+    return result'++-- method TreeDragSource::row_draggable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeDragSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_drag_source_row_draggable" gtk_tree_drag_source_row_draggable :: +    Ptr TreeDragSource ->                   -- _obj : TInterface "Gtk" "TreeDragSource"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO CInt+++treeDragSourceRowDraggable ::+    (MonadIO m, TreeDragSourceK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Bool+treeDragSourceRowDraggable _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_tree_drag_source_row_draggable _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++
+ GI/Gtk/Interfaces/TreeDragSource.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gtk.Interfaces.TreeDragSource where++import Prelude ()+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 TreeDragSource = TreeDragSource (ForeignPtr TreeDragSource)+class ForeignPtrNewtype a => TreeDragSourceK a+instance (ForeignPtrNewtype o, IsDescendantOf TreeDragSource o) => TreeDragSourceK o
+ GI/Gtk/Interfaces/TreeModel.hs view
@@ -0,0 +1,1217 @@++{- |+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.Gtk.Interfaces.TreeModel+    ( ++-- * Exported types+    TreeModel(..)                           ,+    noTreeModel                             ,+    TreeModelK                              ,+    toTreeModel                             ,+++ -- * Methods+-- ** treeModelFilterNew+    treeModelFilterNew                      ,+++-- ** treeModelForeach+    treeModelForeach                        ,+++-- ** treeModelGetColumnType+    treeModelGetColumnType                  ,+++-- ** treeModelGetFlags+    treeModelGetFlags                       ,+++-- ** treeModelGetIter+    treeModelGetIter                        ,+++-- ** treeModelGetIterFirst+    treeModelGetIterFirst                   ,+++-- ** treeModelGetIterFromString+    treeModelGetIterFromString              ,+++-- ** treeModelGetNColumns+    treeModelGetNColumns                    ,+++-- ** treeModelGetPath+    treeModelGetPath                        ,+++-- ** treeModelGetStringFromIter+    treeModelGetStringFromIter              ,+++-- ** treeModelGetValue+    treeModelGetValue                       ,+++-- ** treeModelIterChildren+    treeModelIterChildren                   ,+++-- ** treeModelIterHasChild+    treeModelIterHasChild                   ,+++-- ** treeModelIterNChildren+    treeModelIterNChildren                  ,+++-- ** treeModelIterNext+    treeModelIterNext                       ,+++-- ** treeModelIterNthChild+    treeModelIterNthChild                   ,+++-- ** treeModelIterParent+    treeModelIterParent                     ,+++-- ** treeModelIterPrevious+    treeModelIterPrevious                   ,+++-- ** treeModelRefNode+    treeModelRefNode                        ,+++-- ** treeModelRowChanged+    treeModelRowChanged                     ,+++-- ** treeModelRowDeleted+    treeModelRowDeleted                     ,+++-- ** treeModelRowHasChildToggled+    treeModelRowHasChildToggled             ,+++-- ** treeModelRowInserted+    treeModelRowInserted                    ,+++-- ** treeModelRowsReordered+    treeModelRowsReordered                  ,+++-- ** treeModelSortNewWithModel+    treeModelSortNewWithModel               ,+++-- ** treeModelUnrefNode+    treeModelUnrefNode                      ,+++++ -- * Signals+-- ** RowChanged+    TreeModelRowChangedCallback             ,+    TreeModelRowChangedCallbackC            ,+    TreeModelRowChangedSignalInfo           ,+    afterTreeModelRowChanged                ,+    mkTreeModelRowChangedCallback           ,+    noTreeModelRowChangedCallback           ,+    onTreeModelRowChanged                   ,+    treeModelRowChangedCallbackWrapper      ,+    treeModelRowChangedClosure              ,+++-- ** RowDeleted+    TreeModelRowDeletedCallback             ,+    TreeModelRowDeletedCallbackC            ,+    TreeModelRowDeletedSignalInfo           ,+    afterTreeModelRowDeleted                ,+    mkTreeModelRowDeletedCallback           ,+    noTreeModelRowDeletedCallback           ,+    onTreeModelRowDeleted                   ,+    treeModelRowDeletedCallbackWrapper      ,+    treeModelRowDeletedClosure              ,+++-- ** RowHasChildToggled+    TreeModelRowHasChildToggledCallback     ,+    TreeModelRowHasChildToggledCallbackC    ,+    TreeModelRowHasChildToggledSignalInfo   ,+    afterTreeModelRowHasChildToggled        ,+    mkTreeModelRowHasChildToggledCallback   ,+    noTreeModelRowHasChildToggledCallback   ,+    onTreeModelRowHasChildToggled           ,+    treeModelRowHasChildToggledCallbackWrapper,+    treeModelRowHasChildToggledClosure      ,+++-- ** RowInserted+    TreeModelRowInsertedCallback            ,+    TreeModelRowInsertedCallbackC           ,+    TreeModelRowInsertedSignalInfo          ,+    afterTreeModelRowInserted               ,+    mkTreeModelRowInsertedCallback          ,+    noTreeModelRowInsertedCallback          ,+    onTreeModelRowInserted                  ,+    treeModelRowInsertedCallbackWrapper     ,+    treeModelRowInsertedClosure             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++-- interface TreeModel ++newtype TreeModel = TreeModel (ForeignPtr TreeModel)+noTreeModel :: Maybe TreeModel+noTreeModel = Nothing++-- signal TreeModel::row-changed+type TreeModelRowChangedCallback =+    TreePath ->+    TreeIter ->+    IO ()++noTreeModelRowChangedCallback :: Maybe TreeModelRowChangedCallback+noTreeModelRowChangedCallback = Nothing++type TreeModelRowChangedCallbackC =+    Ptr () ->                               -- object+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkTreeModelRowChangedCallback :: TreeModelRowChangedCallbackC -> IO (FunPtr TreeModelRowChangedCallbackC)++treeModelRowChangedClosure :: TreeModelRowChangedCallback -> IO Closure+treeModelRowChangedClosure cb = newCClosure =<< mkTreeModelRowChangedCallback wrapped+    where wrapped = treeModelRowChangedCallbackWrapper cb++treeModelRowChangedCallbackWrapper ::+    TreeModelRowChangedCallback ->+    Ptr () ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+treeModelRowChangedCallbackWrapper _cb _ path iter _ = do+    path' <- (newBoxed TreePath) path+    iter' <- (newBoxed TreeIter) iter+    _cb  path' iter'++onTreeModelRowChanged :: (GObject a, MonadIO m) => a -> TreeModelRowChangedCallback -> m SignalHandlerId+onTreeModelRowChanged obj cb = liftIO $ connectTreeModelRowChanged obj cb SignalConnectBefore+afterTreeModelRowChanged :: (GObject a, MonadIO m) => a -> TreeModelRowChangedCallback -> m SignalHandlerId+afterTreeModelRowChanged obj cb = connectTreeModelRowChanged obj cb SignalConnectAfter++connectTreeModelRowChanged :: (GObject a, MonadIO m) =>+                              a -> TreeModelRowChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectTreeModelRowChanged obj cb after = liftIO $ do+    cb' <- mkTreeModelRowChangedCallback (treeModelRowChangedCallbackWrapper cb)+    connectSignalFunPtr obj "row-changed" cb' after++-- signal TreeModel::row-deleted+type TreeModelRowDeletedCallback =+    TreePath ->+    IO ()++noTreeModelRowDeletedCallback :: Maybe TreeModelRowDeletedCallback+noTreeModelRowDeletedCallback = Nothing++type TreeModelRowDeletedCallbackC =+    Ptr () ->                               -- object+    Ptr TreePath ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkTreeModelRowDeletedCallback :: TreeModelRowDeletedCallbackC -> IO (FunPtr TreeModelRowDeletedCallbackC)++treeModelRowDeletedClosure :: TreeModelRowDeletedCallback -> IO Closure+treeModelRowDeletedClosure cb = newCClosure =<< mkTreeModelRowDeletedCallback wrapped+    where wrapped = treeModelRowDeletedCallbackWrapper cb++treeModelRowDeletedCallbackWrapper ::+    TreeModelRowDeletedCallback ->+    Ptr () ->+    Ptr TreePath ->+    Ptr () ->+    IO ()+treeModelRowDeletedCallbackWrapper _cb _ path _ = do+    path' <- (newBoxed TreePath) path+    _cb  path'++onTreeModelRowDeleted :: (GObject a, MonadIO m) => a -> TreeModelRowDeletedCallback -> m SignalHandlerId+onTreeModelRowDeleted obj cb = liftIO $ connectTreeModelRowDeleted obj cb SignalConnectBefore+afterTreeModelRowDeleted :: (GObject a, MonadIO m) => a -> TreeModelRowDeletedCallback -> m SignalHandlerId+afterTreeModelRowDeleted obj cb = connectTreeModelRowDeleted obj cb SignalConnectAfter++connectTreeModelRowDeleted :: (GObject a, MonadIO m) =>+                              a -> TreeModelRowDeletedCallback -> SignalConnectMode -> m SignalHandlerId+connectTreeModelRowDeleted obj cb after = liftIO $ do+    cb' <- mkTreeModelRowDeletedCallback (treeModelRowDeletedCallbackWrapper cb)+    connectSignalFunPtr obj "row-deleted" cb' after++-- signal TreeModel::row-has-child-toggled+type TreeModelRowHasChildToggledCallback =+    TreePath ->+    TreeIter ->+    IO ()++noTreeModelRowHasChildToggledCallback :: Maybe TreeModelRowHasChildToggledCallback+noTreeModelRowHasChildToggledCallback = Nothing++type TreeModelRowHasChildToggledCallbackC =+    Ptr () ->                               -- object+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkTreeModelRowHasChildToggledCallback :: TreeModelRowHasChildToggledCallbackC -> IO (FunPtr TreeModelRowHasChildToggledCallbackC)++treeModelRowHasChildToggledClosure :: TreeModelRowHasChildToggledCallback -> IO Closure+treeModelRowHasChildToggledClosure cb = newCClosure =<< mkTreeModelRowHasChildToggledCallback wrapped+    where wrapped = treeModelRowHasChildToggledCallbackWrapper cb++treeModelRowHasChildToggledCallbackWrapper ::+    TreeModelRowHasChildToggledCallback ->+    Ptr () ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+treeModelRowHasChildToggledCallbackWrapper _cb _ path iter _ = do+    path' <- (newBoxed TreePath) path+    iter' <- (newBoxed TreeIter) iter+    _cb  path' iter'++onTreeModelRowHasChildToggled :: (GObject a, MonadIO m) => a -> TreeModelRowHasChildToggledCallback -> m SignalHandlerId+onTreeModelRowHasChildToggled obj cb = liftIO $ connectTreeModelRowHasChildToggled obj cb SignalConnectBefore+afterTreeModelRowHasChildToggled :: (GObject a, MonadIO m) => a -> TreeModelRowHasChildToggledCallback -> m SignalHandlerId+afterTreeModelRowHasChildToggled obj cb = connectTreeModelRowHasChildToggled obj cb SignalConnectAfter++connectTreeModelRowHasChildToggled :: (GObject a, MonadIO m) =>+                                      a -> TreeModelRowHasChildToggledCallback -> SignalConnectMode -> m SignalHandlerId+connectTreeModelRowHasChildToggled obj cb after = liftIO $ do+    cb' <- mkTreeModelRowHasChildToggledCallback (treeModelRowHasChildToggledCallbackWrapper cb)+    connectSignalFunPtr obj "row-has-child-toggled" cb' after++-- signal TreeModel::row-inserted+type TreeModelRowInsertedCallback =+    TreePath ->+    TreeIter ->+    IO ()++noTreeModelRowInsertedCallback :: Maybe TreeModelRowInsertedCallback+noTreeModelRowInsertedCallback = Nothing++type TreeModelRowInsertedCallbackC =+    Ptr () ->                               -- object+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkTreeModelRowInsertedCallback :: TreeModelRowInsertedCallbackC -> IO (FunPtr TreeModelRowInsertedCallbackC)++treeModelRowInsertedClosure :: TreeModelRowInsertedCallback -> IO Closure+treeModelRowInsertedClosure cb = newCClosure =<< mkTreeModelRowInsertedCallback wrapped+    where wrapped = treeModelRowInsertedCallbackWrapper cb++treeModelRowInsertedCallbackWrapper ::+    TreeModelRowInsertedCallback ->+    Ptr () ->+    Ptr TreePath ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+treeModelRowInsertedCallbackWrapper _cb _ path iter _ = do+    path' <- (newBoxed TreePath) path+    iter' <- (newBoxed TreeIter) iter+    _cb  path' iter'++onTreeModelRowInserted :: (GObject a, MonadIO m) => a -> TreeModelRowInsertedCallback -> m SignalHandlerId+onTreeModelRowInserted obj cb = liftIO $ connectTreeModelRowInserted obj cb SignalConnectBefore+afterTreeModelRowInserted :: (GObject a, MonadIO m) => a -> TreeModelRowInsertedCallback -> m SignalHandlerId+afterTreeModelRowInserted obj cb = connectTreeModelRowInserted obj cb SignalConnectAfter++connectTreeModelRowInserted :: (GObject a, MonadIO m) =>+                               a -> TreeModelRowInsertedCallback -> SignalConnectMode -> m SignalHandlerId+connectTreeModelRowInserted obj cb after = liftIO $ do+    cb' <- mkTreeModelRowInsertedCallback (treeModelRowInsertedCallbackWrapper cb)+    connectSignalFunPtr obj "row-inserted" cb' after++type instance AttributeList TreeModel = TreeModelAttributeList+type TreeModelAttributeList = ('[ ] :: [(Symbol, *)])++data TreeModelRowChangedSignalInfo+instance SignalInfo TreeModelRowChangedSignalInfo where+    type HaskellCallbackType TreeModelRowChangedSignalInfo = TreeModelRowChangedCallback+    connectSignal _ = connectTreeModelRowChanged++data TreeModelRowDeletedSignalInfo+instance SignalInfo TreeModelRowDeletedSignalInfo where+    type HaskellCallbackType TreeModelRowDeletedSignalInfo = TreeModelRowDeletedCallback+    connectSignal _ = connectTreeModelRowDeleted++data TreeModelRowHasChildToggledSignalInfo+instance SignalInfo TreeModelRowHasChildToggledSignalInfo where+    type HaskellCallbackType TreeModelRowHasChildToggledSignalInfo = TreeModelRowHasChildToggledCallback+    connectSignal _ = connectTreeModelRowHasChildToggled++data TreeModelRowInsertedSignalInfo+instance SignalInfo TreeModelRowInsertedSignalInfo where+    type HaskellCallbackType TreeModelRowInsertedSignalInfo = TreeModelRowInsertedCallback+    connectSignal _ = connectTreeModelRowInserted++type instance SignalList TreeModel = TreeModelSignalList+type TreeModelSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("row-changed", TreeModelRowChangedSignalInfo), '("row-deleted", TreeModelRowDeletedSignalInfo), '("row-has-child-toggled", TreeModelRowHasChildToggledSignalInfo), '("row-inserted", TreeModelRowInsertedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_tree_model_get_type"+    c_gtk_tree_model_get_type :: IO GType++type instance ParentTypes TreeModel = TreeModelParentTypes+type TreeModelParentTypes = '[GObject.Object]++instance GObject TreeModel where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_tree_model_get_type+    ++class GObject o => TreeModelK o+instance (GObject o, IsDescendantOf TreeModel o) => TreeModelK o++toTreeModel :: TreeModelK o => o -> IO TreeModel+toTreeModel = unsafeCastTo TreeModel++-- method TreeModel::filter_new+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "root", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "root", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_filter_new" gtk_tree_model_filter_new :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- root : TInterface "Gtk" "TreePath"+    IO (Ptr TreeModel)+++treeModelFilterNew ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    Maybe (TreePath) ->                     -- root+    m TreeModel+treeModelFilterNew _obj root = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeRoot <- case root of+        Nothing -> return nullPtr+        Just jRoot -> do+            let jRoot' = unsafeManagedPtrGetPtr jRoot+            return jRoot'+    result <- gtk_tree_model_filter_new _obj' maybeRoot+    checkUnexpectedReturnNULL "gtk_tree_model_filter_new" result+    result' <- (wrapObject TreeModel) result+    touchManagedPtr _obj+    whenJust root touchManagedPtr+    return result'++-- method TreeModel::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TreeModelForeachFunc", 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 "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TreeModelForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_foreach" gtk_tree_model_foreach :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    FunPtr TreeModelForeachFuncC ->         -- func : TInterface "Gtk" "TreeModelForeachFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++treeModelForeach ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeModelForeachFunc ->                 -- func+    m ()+treeModelForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkTreeModelForeachFunc (treeModelForeachFuncWrapper Nothing func)+    let user_data = nullPtr+    gtk_tree_model_foreach _obj' func' user_data+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method TreeModel::get_column_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", 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 "Gtk" "TreeModel", 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 TGType+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_column_type" gtk_tree_model_get_column_type :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Int32 ->                                -- index_ : TBasicType TInt32+    IO CGType+++treeModelGetColumnType ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    m GType+treeModelGetColumnType _obj index_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tree_model_get_column_type _obj' index_+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method TreeModel::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModelFlags"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_flags" gtk_tree_model_get_flags :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    IO CUInt+++treeModelGetFlags ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    m [TreeModelFlags]+treeModelGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tree_model_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method TreeModel::get_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_iter" gtk_tree_model_get_iter :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO CInt+++treeModelGetIter ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m (Bool,TreeIter)+treeModelGetIter _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_tree_model_get_iter _obj' iter path'+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    touchManagedPtr path+    return (result', iter')++-- method TreeModel::get_iter_first+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_iter_first" gtk_tree_model_get_iter_first :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelGetIterFirst ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    m (Bool,TreeIter)+treeModelGetIterFirst _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    result <- gtk_tree_model_get_iter_first _obj' iter+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    return (result', iter')++-- method TreeModel::get_iter_from_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path_string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path_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 "gtk_tree_model_get_iter_from_string" gtk_tree_model_get_iter_from_string :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    CString ->                              -- path_string : TBasicType TUTF8+    IO CInt+++treeModelGetIterFromString ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path_string+    m (Bool,TreeIter)+treeModelGetIterFromString _obj path_string = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    path_string' <- textToCString path_string+    result <- gtk_tree_model_get_iter_from_string _obj' iter path_string'+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    freeMem path_string'+    return (result', iter')++-- method TreeModel::get_n_columns+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_n_columns" gtk_tree_model_get_n_columns :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    IO Int32+++treeModelGetNColumns ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    m Int32+treeModelGetNColumns _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tree_model_get_n_columns _obj'+    touchManagedPtr _obj+    return result++-- method TreeModel::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreePath"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_path" gtk_tree_model_get_path :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO (Ptr TreePath)+++treeModelGetPath ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m TreePath+treeModelGetPath _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_tree_model_get_path _obj' iter'+    checkUnexpectedReturnNULL "gtk_tree_model_get_path" result+    result' <- (wrapBoxed TreePath) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method TreeModel::get_string_from_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_get_string_from_iter" gtk_tree_model_get_string_from_iter :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CString+++treeModelGetStringFromIter ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m T.Text+treeModelGetStringFromIter _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_tree_model_get_string_from_iter _obj' iter'+    checkUnexpectedReturnNULL "gtk_tree_model_get_string_from_iter" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method TreeModel::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_tree_model_get_value" gtk_tree_model_get_value :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Int32 ->                                -- column : TBasicType TInt32+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++treeModelGetValue ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    Int32 ->                                -- column+    m (GValue)+treeModelGetValue _obj iter column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    gtk_tree_model_get_value _obj' iter' column value+    value' <- (wrapBoxed GValue) value+    touchManagedPtr _obj+    touchManagedPtr iter+    return value'++-- method TreeModel::iter_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_children" gtk_tree_model_iter_children :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- parent : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelIterChildren ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- parent+    m (Bool,TreeIter)+treeModelIterChildren _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrGetPtr jParent+            return jParent'+    result <- gtk_tree_model_iter_children _obj' iter maybeParent+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    return (result', iter')++-- method TreeModel::iter_has_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_has_child" gtk_tree_model_iter_has_child :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelIterHasChild ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m Bool+treeModelIterHasChild _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_tree_model_iter_has_child _obj' iter'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method TreeModel::iter_n_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_n_children" gtk_tree_model_iter_n_children :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO Int32+++treeModelIterNChildren ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- iter+    m Int32+treeModelIterNChildren _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIter <- case iter of+        Nothing -> return nullPtr+        Just jIter -> do+            let jIter' = unsafeManagedPtrGetPtr jIter+            return jIter'+    result <- gtk_tree_model_iter_n_children _obj' maybeIter+    touchManagedPtr _obj+    whenJust iter touchManagedPtr+    return result++-- method TreeModel::iter_next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_next" gtk_tree_model_iter_next :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelIterNext ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m Bool+treeModelIterNext _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_tree_model_iter_next _obj' iter'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method TreeModel::iter_nth_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n", 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 "gtk_tree_model_iter_nth_child" gtk_tree_model_iter_nth_child :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- parent : TInterface "Gtk" "TreeIter"+    Int32 ->                                -- n : TBasicType TInt32+    IO CInt+++treeModelIterNthChild ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- parent+    Int32 ->                                -- n+    m (Bool,TreeIter)+treeModelIterNthChild _obj parent n = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrGetPtr jParent+            return jParent'+    result <- gtk_tree_model_iter_nth_child _obj' iter maybeParent n+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    return (result', iter')++-- method TreeModel::iter_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_parent" gtk_tree_model_iter_parent :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- child : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelIterParent ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- child+    m (Bool,TreeIter)+treeModelIterParent _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    let child' = unsafeManagedPtrGetPtr child+    result <- gtk_tree_model_iter_parent _obj' iter child'+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    touchManagedPtr child+    return (result', iter')++-- method TreeModel::iter_previous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_iter_previous" gtk_tree_model_iter_previous :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++treeModelIterPrevious ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m Bool+treeModelIterPrevious _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_tree_model_iter_previous _obj' iter'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method TreeModel::ref_node+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_ref_node" gtk_tree_model_ref_node :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++treeModelRefNode ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m ()+treeModelRefNode _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    gtk_tree_model_ref_node _obj' iter'+    touchManagedPtr _obj+    touchManagedPtr iter+    return ()++-- method TreeModel::row_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_row_changed" gtk_tree_model_row_changed :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++treeModelRowChanged ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    TreeIter ->                             -- iter+    m ()+treeModelRowChanged _obj path iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let iter' = unsafeManagedPtrGetPtr iter+    gtk_tree_model_row_changed _obj' path' iter'+    touchManagedPtr _obj+    touchManagedPtr path+    touchManagedPtr iter+    return ()++-- method TreeModel::row_deleted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_row_deleted" gtk_tree_model_row_deleted :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++treeModelRowDeleted ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m ()+treeModelRowDeleted _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    gtk_tree_model_row_deleted _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return ()++-- method TreeModel::row_has_child_toggled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_row_has_child_toggled" gtk_tree_model_row_has_child_toggled :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++treeModelRowHasChildToggled ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    TreeIter ->                             -- iter+    m ()+treeModelRowHasChildToggled _obj path iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let iter' = unsafeManagedPtrGetPtr iter+    gtk_tree_model_row_has_child_toggled _obj' path' iter'+    touchManagedPtr _obj+    touchManagedPtr path+    touchManagedPtr iter+    return ()++-- method TreeModel::row_inserted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_row_inserted" gtk_tree_model_row_inserted :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++treeModelRowInserted ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    TreeIter ->                             -- iter+    m ()+treeModelRowInserted _obj path iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let iter' = unsafeManagedPtrGetPtr iter+    gtk_tree_model_row_inserted _obj' path' iter'+    touchManagedPtr _obj+    touchManagedPtr path+    touchManagedPtr iter+    return ()++-- method TreeModel::rows_reordered+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray False (-1) 4 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray False (-1) 4 (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 "gtk_tree_model_rows_reordered_with_length" gtk_tree_model_rows_reordered_with_length :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr Int32 ->                            -- new_order : TCArray False (-1) 4 (TBasicType TInt32)+    Int32 ->                                -- length : TBasicType TInt32+    IO ()+++treeModelRowsReordered ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    Maybe (TreeIter) ->                     -- iter+    [Int32] ->                              -- new_order+    m ()+treeModelRowsReordered _obj path iter new_order = liftIO $ do+    let length_ = fromIntegral $ length new_order+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    maybeIter <- case iter of+        Nothing -> return nullPtr+        Just jIter -> do+            let jIter' = unsafeManagedPtrGetPtr jIter+            return jIter'+    new_order' <- packStorableArray new_order+    gtk_tree_model_rows_reordered_with_length _obj' path' maybeIter new_order' length_+    touchManagedPtr _obj+    touchManagedPtr path+    whenJust iter touchManagedPtr+    freeMem new_order'+    return ()++-- method TreeModel::sort_new_with_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_sort_new_with_model" gtk_tree_model_sort_new_with_model :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    IO (Ptr TreeModel)+++treeModelSortNewWithModel ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    m TreeModel+treeModelSortNewWithModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tree_model_sort_new_with_model _obj'+    checkUnexpectedReturnNULL "gtk_tree_model_sort_new_with_model" result+    result' <- (wrapObject TreeModel) result+    touchManagedPtr _obj+    return result'++-- method TreeModel::unref_node+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_model_unref_node" gtk_tree_model_unref_node :: +    Ptr TreeModel ->                        -- _obj : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++treeModelUnrefNode ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m ()+treeModelUnrefNode _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    gtk_tree_model_unref_node _obj' iter'+    touchManagedPtr _obj+    touchManagedPtr iter+    return ()++
+ GI/Gtk/Interfaces/TreeModel.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Interfaces.TreeModel where++import Prelude ()+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 TreeModel = TreeModel (ForeignPtr TreeModel)+data TreeModelRowChangedSignalInfo+data TreeModelRowDeletedSignalInfo+data TreeModelRowHasChildToggledSignalInfo+data TreeModelRowInsertedSignalInfo+instance GObject TreeModel where+class GObject o => TreeModelK o+instance (GObject o, IsDescendantOf TreeModel o) => TreeModelK o
+ GI/Gtk/Interfaces/TreeSortable.hs view
@@ -0,0 +1,322 @@++{- |+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.Gtk.Interfaces.TreeSortable+    ( ++-- * Exported types+    TreeSortable(..)                        ,+    noTreeSortable                          ,+    TreeSortableK                           ,+    toTreeSortable                          ,+++ -- * Methods+-- ** treeSortableGetSortColumnId+    treeSortableGetSortColumnId             ,+++-- ** treeSortableHasDefaultSortFunc+    treeSortableHasDefaultSortFunc          ,+++-- ** treeSortableSetDefaultSortFunc+    treeSortableSetDefaultSortFunc          ,+++-- ** treeSortableSetSortColumnId+    treeSortableSetSortColumnId             ,+++-- ** treeSortableSetSortFunc+    treeSortableSetSortFunc                 ,+++-- ** treeSortableSortColumnChanged+    treeSortableSortColumnChanged           ,+++++ -- * Signals+-- ** SortColumnChanged+    TreeSortableSortColumnChangedCallback   ,+    TreeSortableSortColumnChangedCallbackC  ,+    TreeSortableSortColumnChangedSignalInfo ,+    afterTreeSortableSortColumnChanged      ,+    mkTreeSortableSortColumnChangedCallback ,+    noTreeSortableSortColumnChangedCallback ,+    onTreeSortableSortColumnChanged         ,+    treeSortableSortColumnChangedCallbackWrapper,+    treeSortableSortColumnChangedClosure    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- interface TreeSortable ++newtype TreeSortable = TreeSortable (ForeignPtr TreeSortable)+noTreeSortable :: Maybe TreeSortable+noTreeSortable = Nothing++-- signal TreeSortable::sort-column-changed+type TreeSortableSortColumnChangedCallback =+    IO ()++noTreeSortableSortColumnChangedCallback :: Maybe TreeSortableSortColumnChangedCallback+noTreeSortableSortColumnChangedCallback = Nothing++type TreeSortableSortColumnChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkTreeSortableSortColumnChangedCallback :: TreeSortableSortColumnChangedCallbackC -> IO (FunPtr TreeSortableSortColumnChangedCallbackC)++treeSortableSortColumnChangedClosure :: TreeSortableSortColumnChangedCallback -> IO Closure+treeSortableSortColumnChangedClosure cb = newCClosure =<< mkTreeSortableSortColumnChangedCallback wrapped+    where wrapped = treeSortableSortColumnChangedCallbackWrapper cb++treeSortableSortColumnChangedCallbackWrapper ::+    TreeSortableSortColumnChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+treeSortableSortColumnChangedCallbackWrapper _cb _ _ = do+    _cb ++onTreeSortableSortColumnChanged :: (GObject a, MonadIO m) => a -> TreeSortableSortColumnChangedCallback -> m SignalHandlerId+onTreeSortableSortColumnChanged obj cb = liftIO $ connectTreeSortableSortColumnChanged obj cb SignalConnectBefore+afterTreeSortableSortColumnChanged :: (GObject a, MonadIO m) => a -> TreeSortableSortColumnChangedCallback -> m SignalHandlerId+afterTreeSortableSortColumnChanged obj cb = connectTreeSortableSortColumnChanged obj cb SignalConnectAfter++connectTreeSortableSortColumnChanged :: (GObject a, MonadIO m) =>+                                        a -> TreeSortableSortColumnChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectTreeSortableSortColumnChanged obj cb after = liftIO $ do+    cb' <- mkTreeSortableSortColumnChangedCallback (treeSortableSortColumnChangedCallbackWrapper cb)+    connectSignalFunPtr obj "sort-column-changed" cb' after++type instance AttributeList TreeSortable = TreeSortableAttributeList+type TreeSortableAttributeList = ('[ ] :: [(Symbol, *)])++data TreeSortableSortColumnChangedSignalInfo+instance SignalInfo TreeSortableSortColumnChangedSignalInfo where+    type HaskellCallbackType TreeSortableSortColumnChangedSignalInfo = TreeSortableSortColumnChangedCallback+    connectSignal _ = connectTreeSortableSortColumnChanged++type instance SignalList TreeSortable = TreeSortableSignalList+type TreeSortableSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("row-changed", TreeModelRowChangedSignalInfo), '("row-deleted", TreeModelRowDeletedSignalInfo), '("row-has-child-toggled", TreeModelRowHasChildToggledSignalInfo), '("row-inserted", TreeModelRowInsertedSignalInfo), '("sort-column-changed", TreeSortableSortColumnChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gtk_tree_sortable_get_type"+    c_gtk_tree_sortable_get_type :: IO GType++type instance ParentTypes TreeSortable = TreeSortableParentTypes+type TreeSortableParentTypes = '[TreeModel, GObject.Object]++instance GObject TreeSortable where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_tree_sortable_get_type+    ++class GObject o => TreeSortableK o+instance (GObject o, IsDescendantOf TreeSortable o) => TreeSortableK o++toTreeSortable :: TreeSortableK o => o -> IO TreeSortable+toTreeSortable = unsafeCastTo TreeSortable++-- method TreeSortable::get_sort_column_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_column_id", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "order", argType = TInterface "Gtk" "SortType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_get_sort_column_id" gtk_tree_sortable_get_sort_column_id :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    Ptr Int32 ->                            -- sort_column_id : TBasicType TInt32+    Ptr CUInt ->                            -- order : TInterface "Gtk" "SortType"+    IO CInt+++treeSortableGetSortColumnId ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    m (Bool,Int32,SortType)+treeSortableGetSortColumnId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    sort_column_id <- allocMem :: IO (Ptr Int32)+    order <- allocMem :: IO (Ptr CUInt)+    result <- gtk_tree_sortable_get_sort_column_id _obj' sort_column_id order+    let result' = (/= 0) result+    sort_column_id' <- peek sort_column_id+    order' <- peek order+    let order'' = (toEnum . fromIntegral) order'+    touchManagedPtr _obj+    freeMem sort_column_id+    freeMem order+    return (result', sort_column_id', order'')++-- method TreeSortable::has_default_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_has_default_sort_func" gtk_tree_sortable_has_default_sort_func :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    IO CInt+++treeSortableHasDefaultSortFunc ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    m Bool+treeSortableHasDefaultSortFunc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_tree_sortable_has_default_sort_func _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TreeSortable::set_default_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "TreeIterCompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, 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 "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "TreeIterCompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_set_default_sort_func" gtk_tree_sortable_set_default_sort_func :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    FunPtr TreeIterCompareFuncC ->          -- sort_func : TInterface "Gtk" "TreeIterCompareFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++treeSortableSetDefaultSortFunc ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    TreeIterCompareFunc ->                  -- sort_func+    m ()+treeSortableSetDefaultSortFunc _obj sort_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    sort_func' <- mkTreeIterCompareFunc (treeIterCompareFuncWrapper Nothing sort_func)+    let user_data = castFunPtrToPtr sort_func'+    let destroy = safeFreeFunPtrPtr+    gtk_tree_sortable_set_default_sort_func _obj' sort_func' user_data destroy+    touchManagedPtr _obj+    return ()++-- method TreeSortable::set_sort_column_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_column_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gtk" "SortType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_column_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "order", argType = TInterface "Gtk" "SortType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_set_sort_column_id" gtk_tree_sortable_set_sort_column_id :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    Int32 ->                                -- sort_column_id : TBasicType TInt32+    CUInt ->                                -- order : TInterface "Gtk" "SortType"+    IO ()+++treeSortableSetSortColumnId ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- sort_column_id+    SortType ->                             -- order+    m ()+treeSortableSetSortColumnId _obj sort_column_id order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let order' = (fromIntegral . fromEnum) order+    gtk_tree_sortable_set_sort_column_id _obj' sort_column_id order'+    touchManagedPtr _obj+    return ()++-- method TreeSortable::set_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_column_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "TreeIterCompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, 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 "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_column_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "TreeIterCompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_set_sort_func" gtk_tree_sortable_set_sort_func :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    Int32 ->                                -- sort_column_id : TBasicType TInt32+    FunPtr TreeIterCompareFuncC ->          -- sort_func : TInterface "Gtk" "TreeIterCompareFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++treeSortableSetSortFunc ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- sort_column_id+    TreeIterCompareFunc ->                  -- sort_func+    m ()+treeSortableSetSortFunc _obj sort_column_id sort_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    sort_func' <- mkTreeIterCompareFunc (treeIterCompareFuncWrapper Nothing sort_func)+    let user_data = castFunPtrToPtr sort_func'+    let destroy = safeFreeFunPtrPtr+    gtk_tree_sortable_set_sort_func _obj' sort_column_id sort_func' user_data destroy+    touchManagedPtr _obj+    return ()++-- method TreeSortable::sort_column_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "TreeSortable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_tree_sortable_sort_column_changed" gtk_tree_sortable_sort_column_changed :: +    Ptr TreeSortable ->                     -- _obj : TInterface "Gtk" "TreeSortable"+    IO ()+++treeSortableSortColumnChanged ::+    (MonadIO m, TreeSortableK a) =>+    a ->                                    -- _obj+    m ()+treeSortableSortColumnChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_tree_sortable_sort_column_changed _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Interfaces/TreeSortable.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Interfaces.TreeSortable where++import Prelude ()+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 TreeSortable = TreeSortable (ForeignPtr TreeSortable)+data TreeSortableSortColumnChangedSignalInfo+instance GObject TreeSortable where+class GObject o => TreeSortableK o+instance (GObject o, IsDescendantOf TreeSortable o) => TreeSortableK o
+ GI/Gtk/Objects.hs view
@@ -0,0 +1,534 @@++{- |+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.Gtk.Objects+    (     module GI.Gtk.Objects.AboutDialog       ,+    module GI.Gtk.Objects.AccelGroup        ,+    module GI.Gtk.Objects.AccelLabel        ,+    module GI.Gtk.Objects.AccelMap          ,+    module GI.Gtk.Objects.Accessible        ,+    module GI.Gtk.Objects.Action            ,+    module GI.Gtk.Objects.ActionBar         ,+    module GI.Gtk.Objects.ActionGroup       ,+    module GI.Gtk.Objects.Adjustment        ,+    module GI.Gtk.Objects.Alignment         ,+    module GI.Gtk.Objects.AppChooserButton  ,+    module GI.Gtk.Objects.AppChooserDialog  ,+    module GI.Gtk.Objects.AppChooserWidget  ,+    module GI.Gtk.Objects.Application       ,+    module GI.Gtk.Objects.ApplicationWindow ,+    module GI.Gtk.Objects.Arrow             ,+    module GI.Gtk.Objects.ArrowAccessible   ,+    module GI.Gtk.Objects.AspectFrame       ,+    module GI.Gtk.Objects.Assistant         ,+    module GI.Gtk.Objects.Bin               ,+    module GI.Gtk.Objects.BooleanCellAccessible,+    module GI.Gtk.Objects.Box               ,+    module GI.Gtk.Objects.Builder           ,+    module GI.Gtk.Objects.Button            ,+    module GI.Gtk.Objects.ButtonAccessible  ,+    module GI.Gtk.Objects.ButtonBox         ,+    module GI.Gtk.Objects.Calendar          ,+    module GI.Gtk.Objects.CellAccessible    ,+    module GI.Gtk.Objects.CellArea          ,+    module GI.Gtk.Objects.CellAreaBox       ,+    module GI.Gtk.Objects.CellAreaContext   ,+    module GI.Gtk.Objects.CellRenderer      ,+    module GI.Gtk.Objects.CellRendererAccel ,+    module GI.Gtk.Objects.CellRendererCombo ,+    module GI.Gtk.Objects.CellRendererPixbuf,+    module GI.Gtk.Objects.CellRendererProgress,+    module GI.Gtk.Objects.CellRendererSpin  ,+    module GI.Gtk.Objects.CellRendererSpinner,+    module GI.Gtk.Objects.CellRendererText  ,+    module GI.Gtk.Objects.CellRendererToggle,+    module GI.Gtk.Objects.CellView          ,+    module GI.Gtk.Objects.CheckButton       ,+    module GI.Gtk.Objects.CheckMenuItem     ,+    module GI.Gtk.Objects.CheckMenuItemAccessible,+    module GI.Gtk.Objects.Clipboard         ,+    module GI.Gtk.Objects.ColorButton       ,+    module GI.Gtk.Objects.ColorChooserDialog,+    module GI.Gtk.Objects.ColorChooserWidget,+    module GI.Gtk.Objects.ColorSelection    ,+    module GI.Gtk.Objects.ColorSelectionDialog,+    module GI.Gtk.Objects.ComboBox          ,+    module GI.Gtk.Objects.ComboBoxAccessible,+    module GI.Gtk.Objects.ComboBoxText      ,+    module GI.Gtk.Objects.Container         ,+    module GI.Gtk.Objects.ContainerAccessible,+    module GI.Gtk.Objects.ContainerCellAccessible,+    module GI.Gtk.Objects.CssProvider       ,+    module GI.Gtk.Objects.Dialog            ,+    module GI.Gtk.Objects.DrawingArea       ,+    module GI.Gtk.Objects.Entry             ,+    module GI.Gtk.Objects.EntryAccessible   ,+    module GI.Gtk.Objects.EntryBuffer       ,+    module GI.Gtk.Objects.EntryCompletion   ,+    module GI.Gtk.Objects.EntryIconAccessible,+    module GI.Gtk.Objects.EventBox          ,+    module GI.Gtk.Objects.EventController   ,+    module GI.Gtk.Objects.Expander          ,+    module GI.Gtk.Objects.ExpanderAccessible,+    module GI.Gtk.Objects.FileChooserButton ,+    module GI.Gtk.Objects.FileChooserDialog ,+    module GI.Gtk.Objects.FileChooserWidget ,+    module GI.Gtk.Objects.FileFilter        ,+    module GI.Gtk.Objects.Fixed             ,+    module GI.Gtk.Objects.FlowBox           ,+    module GI.Gtk.Objects.FlowBoxAccessible ,+    module GI.Gtk.Objects.FlowBoxChild      ,+    module GI.Gtk.Objects.FlowBoxChildAccessible,+    module GI.Gtk.Objects.FontButton        ,+    module GI.Gtk.Objects.FontChooserDialog ,+    module GI.Gtk.Objects.FontChooserWidget ,+    module GI.Gtk.Objects.FontSelection     ,+    module GI.Gtk.Objects.FontSelectionDialog,+    module GI.Gtk.Objects.Frame             ,+    module GI.Gtk.Objects.FrameAccessible   ,+    module GI.Gtk.Objects.GLArea            ,+    module GI.Gtk.Objects.Gesture           ,+    module GI.Gtk.Objects.GestureDrag       ,+    module GI.Gtk.Objects.GestureLongPress  ,+    module GI.Gtk.Objects.GestureMultiPress ,+    module GI.Gtk.Objects.GesturePan        ,+    module GI.Gtk.Objects.GestureRotate     ,+    module GI.Gtk.Objects.GestureSingle     ,+    module GI.Gtk.Objects.GestureSwipe      ,+    module GI.Gtk.Objects.GestureZoom       ,+    module GI.Gtk.Objects.Grid              ,+    module GI.Gtk.Objects.HBox              ,+    module GI.Gtk.Objects.HButtonBox        ,+    module GI.Gtk.Objects.HPaned            ,+    module GI.Gtk.Objects.HSV               ,+    module GI.Gtk.Objects.HScale            ,+    module GI.Gtk.Objects.HScrollbar        ,+    module GI.Gtk.Objects.HSeparator        ,+    module GI.Gtk.Objects.HandleBox         ,+    module GI.Gtk.Objects.HeaderBar         ,+    module GI.Gtk.Objects.IMContext         ,+    module GI.Gtk.Objects.IMContextSimple   ,+    module GI.Gtk.Objects.IMMulticontext    ,+    module GI.Gtk.Objects.IconFactory       ,+    module GI.Gtk.Objects.IconInfo          ,+    module GI.Gtk.Objects.IconTheme         ,+    module GI.Gtk.Objects.IconView          ,+    module GI.Gtk.Objects.IconViewAccessible,+    module GI.Gtk.Objects.Image             ,+    module GI.Gtk.Objects.ImageAccessible   ,+    module GI.Gtk.Objects.ImageCellAccessible,+    module GI.Gtk.Objects.ImageMenuItem     ,+    module GI.Gtk.Objects.InfoBar           ,+    module GI.Gtk.Objects.Invisible         ,+    module GI.Gtk.Objects.Label             ,+    module GI.Gtk.Objects.LabelAccessible   ,+    module GI.Gtk.Objects.Layout            ,+    module GI.Gtk.Objects.LevelBar          ,+    module GI.Gtk.Objects.LevelBarAccessible,+    module GI.Gtk.Objects.LinkButton        ,+    module GI.Gtk.Objects.LinkButtonAccessible,+    module GI.Gtk.Objects.ListBox           ,+    module GI.Gtk.Objects.ListBoxAccessible ,+    module GI.Gtk.Objects.ListBoxRow        ,+    module GI.Gtk.Objects.ListBoxRowAccessible,+    module GI.Gtk.Objects.ListStore         ,+    module GI.Gtk.Objects.LockButton        ,+    module GI.Gtk.Objects.LockButtonAccessible,+    module GI.Gtk.Objects.Menu              ,+    module GI.Gtk.Objects.MenuAccessible    ,+    module GI.Gtk.Objects.MenuBar           ,+    module GI.Gtk.Objects.MenuButton        ,+    module GI.Gtk.Objects.MenuButtonAccessible,+    module GI.Gtk.Objects.MenuItem          ,+    module GI.Gtk.Objects.MenuItemAccessible,+    module GI.Gtk.Objects.MenuShell         ,+    module GI.Gtk.Objects.MenuShellAccessible,+    module GI.Gtk.Objects.MenuToolButton    ,+    module GI.Gtk.Objects.MessageDialog     ,+    module GI.Gtk.Objects.Misc              ,+    module GI.Gtk.Objects.ModelButton       ,+    module GI.Gtk.Objects.MountOperation    ,+    module GI.Gtk.Objects.Notebook          ,+    module GI.Gtk.Objects.NotebookAccessible,+    module GI.Gtk.Objects.NotebookPageAccessible,+    module GI.Gtk.Objects.NumerableIcon     ,+    module GI.Gtk.Objects.OffscreenWindow   ,+    module GI.Gtk.Objects.Overlay           ,+    module GI.Gtk.Objects.PageSetup         ,+    module GI.Gtk.Objects.Paned             ,+    module GI.Gtk.Objects.PanedAccessible   ,+    module GI.Gtk.Objects.PlacesSidebar     ,+    module GI.Gtk.Objects.Plug              ,+    module GI.Gtk.Objects.Popover           ,+    module GI.Gtk.Objects.PopoverAccessible ,+    module GI.Gtk.Objects.PopoverMenu       ,+    module GI.Gtk.Objects.PrintContext      ,+    module GI.Gtk.Objects.PrintOperation    ,+    module GI.Gtk.Objects.PrintSettings     ,+    module GI.Gtk.Objects.ProgressBar       ,+    module GI.Gtk.Objects.ProgressBarAccessible,+    module GI.Gtk.Objects.RadioAction       ,+    module GI.Gtk.Objects.RadioButton       ,+    module GI.Gtk.Objects.RadioButtonAccessible,+    module GI.Gtk.Objects.RadioMenuItem     ,+    module GI.Gtk.Objects.RadioMenuItemAccessible,+    module GI.Gtk.Objects.RadioToolButton   ,+    module GI.Gtk.Objects.Range             ,+    module GI.Gtk.Objects.RangeAccessible   ,+    module GI.Gtk.Objects.RcStyle           ,+    module GI.Gtk.Objects.RecentAction      ,+    module GI.Gtk.Objects.RecentChooserDialog,+    module GI.Gtk.Objects.RecentChooserMenu ,+    module GI.Gtk.Objects.RecentChooserWidget,+    module GI.Gtk.Objects.RecentFilter      ,+    module GI.Gtk.Objects.RecentManager     ,+    module GI.Gtk.Objects.RendererCellAccessible,+    module GI.Gtk.Objects.Revealer          ,+    module GI.Gtk.Objects.Scale             ,+    module GI.Gtk.Objects.ScaleAccessible   ,+    module GI.Gtk.Objects.ScaleButton       ,+    module GI.Gtk.Objects.ScaleButtonAccessible,+    module GI.Gtk.Objects.Scrollbar         ,+    module GI.Gtk.Objects.ScrolledWindow    ,+    module GI.Gtk.Objects.ScrolledWindowAccessible,+    module GI.Gtk.Objects.SearchBar         ,+    module GI.Gtk.Objects.SearchEntry       ,+    module GI.Gtk.Objects.Separator         ,+    module GI.Gtk.Objects.SeparatorMenuItem ,+    module GI.Gtk.Objects.SeparatorToolItem ,+    module GI.Gtk.Objects.Settings          ,+    module GI.Gtk.Objects.SizeGroup         ,+    module GI.Gtk.Objects.Socket            ,+    module GI.Gtk.Objects.SpinButton        ,+    module GI.Gtk.Objects.SpinButtonAccessible,+    module GI.Gtk.Objects.Spinner           ,+    module GI.Gtk.Objects.SpinnerAccessible ,+    module GI.Gtk.Objects.Stack             ,+    module GI.Gtk.Objects.StackSidebar      ,+    module GI.Gtk.Objects.StackSwitcher     ,+    module GI.Gtk.Objects.StatusIcon        ,+    module GI.Gtk.Objects.Statusbar         ,+    module GI.Gtk.Objects.StatusbarAccessible,+    module GI.Gtk.Objects.Style             ,+    module GI.Gtk.Objects.StyleContext      ,+    module GI.Gtk.Objects.StyleProperties   ,+    module GI.Gtk.Objects.Switch            ,+    module GI.Gtk.Objects.SwitchAccessible  ,+    module GI.Gtk.Objects.Table             ,+    module GI.Gtk.Objects.TearoffMenuItem   ,+    module GI.Gtk.Objects.TextBuffer        ,+    module GI.Gtk.Objects.TextCellAccessible,+    module GI.Gtk.Objects.TextChildAnchor   ,+    module GI.Gtk.Objects.TextMark          ,+    module GI.Gtk.Objects.TextTag           ,+    module GI.Gtk.Objects.TextTagTable      ,+    module GI.Gtk.Objects.TextView          ,+    module GI.Gtk.Objects.TextViewAccessible,+    module GI.Gtk.Objects.ThemingEngine     ,+    module GI.Gtk.Objects.ToggleAction      ,+    module GI.Gtk.Objects.ToggleButton      ,+    module GI.Gtk.Objects.ToggleButtonAccessible,+    module GI.Gtk.Objects.ToggleToolButton  ,+    module GI.Gtk.Objects.ToolButton        ,+    module GI.Gtk.Objects.ToolItem          ,+    module GI.Gtk.Objects.ToolItemGroup     ,+    module GI.Gtk.Objects.ToolPalette       ,+    module GI.Gtk.Objects.Toolbar           ,+    module GI.Gtk.Objects.Tooltip           ,+    module GI.Gtk.Objects.ToplevelAccessible,+    module GI.Gtk.Objects.TreeModelFilter   ,+    module GI.Gtk.Objects.TreeModelSort     ,+    module GI.Gtk.Objects.TreeSelection     ,+    module GI.Gtk.Objects.TreeStore         ,+    module GI.Gtk.Objects.TreeView          ,+    module GI.Gtk.Objects.TreeViewAccessible,+    module GI.Gtk.Objects.TreeViewColumn    ,+    module GI.Gtk.Objects.UIManager         ,+    module GI.Gtk.Objects.VBox              ,+    module GI.Gtk.Objects.VButtonBox        ,+    module GI.Gtk.Objects.VPaned            ,+    module GI.Gtk.Objects.VScale            ,+    module GI.Gtk.Objects.VScrollbar        ,+    module GI.Gtk.Objects.VSeparator        ,+    module GI.Gtk.Objects.Viewport          ,+    module GI.Gtk.Objects.VolumeButton      ,+    module GI.Gtk.Objects.Widget            ,+    module GI.Gtk.Objects.WidgetAccessible  ,+    module GI.Gtk.Objects.Window            ,+    module GI.Gtk.Objects.WindowAccessible  ,+    module GI.Gtk.Objects.WindowGroup       ,+++    ) where++import GI.Gtk.Objects.AboutDialog+import GI.Gtk.Objects.AccelGroup+import GI.Gtk.Objects.AccelLabel+import GI.Gtk.Objects.AccelMap+import GI.Gtk.Objects.Accessible+import GI.Gtk.Objects.Action+import GI.Gtk.Objects.ActionBar+import GI.Gtk.Objects.ActionGroup+import GI.Gtk.Objects.Adjustment+import GI.Gtk.Objects.Alignment+import GI.Gtk.Objects.AppChooserButton+import GI.Gtk.Objects.AppChooserDialog+import GI.Gtk.Objects.AppChooserWidget+import GI.Gtk.Objects.Application+import GI.Gtk.Objects.ApplicationWindow+import GI.Gtk.Objects.Arrow+import GI.Gtk.Objects.ArrowAccessible+import GI.Gtk.Objects.AspectFrame+import GI.Gtk.Objects.Assistant+import GI.Gtk.Objects.Bin+import GI.Gtk.Objects.BooleanCellAccessible+import GI.Gtk.Objects.Box+import GI.Gtk.Objects.Builder+import GI.Gtk.Objects.Button+import GI.Gtk.Objects.ButtonAccessible+import GI.Gtk.Objects.ButtonBox+import GI.Gtk.Objects.Calendar+import GI.Gtk.Objects.CellAccessible+import GI.Gtk.Objects.CellArea+import GI.Gtk.Objects.CellAreaBox+import GI.Gtk.Objects.CellAreaContext+import GI.Gtk.Objects.CellRenderer+import GI.Gtk.Objects.CellRendererAccel+import GI.Gtk.Objects.CellRendererCombo+import GI.Gtk.Objects.CellRendererPixbuf+import GI.Gtk.Objects.CellRendererProgress+import GI.Gtk.Objects.CellRendererSpin+import GI.Gtk.Objects.CellRendererSpinner+import GI.Gtk.Objects.CellRendererText+import GI.Gtk.Objects.CellRendererToggle+import GI.Gtk.Objects.CellView+import GI.Gtk.Objects.CheckButton+import GI.Gtk.Objects.CheckMenuItem+import GI.Gtk.Objects.CheckMenuItemAccessible+import GI.Gtk.Objects.Clipboard+import GI.Gtk.Objects.ColorButton+import GI.Gtk.Objects.ColorChooserDialog+import GI.Gtk.Objects.ColorChooserWidget+import GI.Gtk.Objects.ColorSelection+import GI.Gtk.Objects.ColorSelectionDialog+import GI.Gtk.Objects.ComboBox+import GI.Gtk.Objects.ComboBoxAccessible+import GI.Gtk.Objects.ComboBoxText+import GI.Gtk.Objects.Container+import GI.Gtk.Objects.ContainerAccessible+import GI.Gtk.Objects.ContainerCellAccessible+import GI.Gtk.Objects.CssProvider+import GI.Gtk.Objects.Dialog+import GI.Gtk.Objects.DrawingArea+import GI.Gtk.Objects.Entry+import GI.Gtk.Objects.EntryAccessible+import GI.Gtk.Objects.EntryBuffer+import GI.Gtk.Objects.EntryCompletion+import GI.Gtk.Objects.EntryIconAccessible+import GI.Gtk.Objects.EventBox+import GI.Gtk.Objects.EventController+import GI.Gtk.Objects.Expander+import GI.Gtk.Objects.ExpanderAccessible+import GI.Gtk.Objects.FileChooserButton+import GI.Gtk.Objects.FileChooserDialog+import GI.Gtk.Objects.FileChooserWidget+import GI.Gtk.Objects.FileFilter+import GI.Gtk.Objects.Fixed+import GI.Gtk.Objects.FlowBox+import GI.Gtk.Objects.FlowBoxAccessible+import GI.Gtk.Objects.FlowBoxChild+import GI.Gtk.Objects.FlowBoxChildAccessible+import GI.Gtk.Objects.FontButton+import GI.Gtk.Objects.FontChooserDialog+import GI.Gtk.Objects.FontChooserWidget+import GI.Gtk.Objects.FontSelection+import GI.Gtk.Objects.FontSelectionDialog+import GI.Gtk.Objects.Frame+import GI.Gtk.Objects.FrameAccessible+import GI.Gtk.Objects.GLArea+import GI.Gtk.Objects.Gesture+import GI.Gtk.Objects.GestureDrag+import GI.Gtk.Objects.GestureLongPress+import GI.Gtk.Objects.GestureMultiPress+import GI.Gtk.Objects.GesturePan+import GI.Gtk.Objects.GestureRotate+import GI.Gtk.Objects.GestureSingle+import GI.Gtk.Objects.GestureSwipe+import GI.Gtk.Objects.GestureZoom+import GI.Gtk.Objects.Grid+import GI.Gtk.Objects.HBox+import GI.Gtk.Objects.HButtonBox+import GI.Gtk.Objects.HPaned+import GI.Gtk.Objects.HSV+import GI.Gtk.Objects.HScale+import GI.Gtk.Objects.HScrollbar+import GI.Gtk.Objects.HSeparator+import GI.Gtk.Objects.HandleBox+import GI.Gtk.Objects.HeaderBar+import GI.Gtk.Objects.IMContext+import GI.Gtk.Objects.IMContextSimple+import GI.Gtk.Objects.IMMulticontext+import GI.Gtk.Objects.IconFactory+import GI.Gtk.Objects.IconInfo+import GI.Gtk.Objects.IconTheme+import GI.Gtk.Objects.IconView+import GI.Gtk.Objects.IconViewAccessible+import GI.Gtk.Objects.Image+import GI.Gtk.Objects.ImageAccessible+import GI.Gtk.Objects.ImageCellAccessible+import GI.Gtk.Objects.ImageMenuItem+import GI.Gtk.Objects.InfoBar+import GI.Gtk.Objects.Invisible+import GI.Gtk.Objects.Label+import GI.Gtk.Objects.LabelAccessible+import GI.Gtk.Objects.Layout+import GI.Gtk.Objects.LevelBar+import GI.Gtk.Objects.LevelBarAccessible+import GI.Gtk.Objects.LinkButton+import GI.Gtk.Objects.LinkButtonAccessible+import GI.Gtk.Objects.ListBox+import GI.Gtk.Objects.ListBoxAccessible+import GI.Gtk.Objects.ListBoxRow+import GI.Gtk.Objects.ListBoxRowAccessible+import GI.Gtk.Objects.ListStore+import GI.Gtk.Objects.LockButton+import GI.Gtk.Objects.LockButtonAccessible+import GI.Gtk.Objects.Menu+import GI.Gtk.Objects.MenuAccessible+import GI.Gtk.Objects.MenuBar+import GI.Gtk.Objects.MenuButton+import GI.Gtk.Objects.MenuButtonAccessible+import GI.Gtk.Objects.MenuItem+import GI.Gtk.Objects.MenuItemAccessible+import GI.Gtk.Objects.MenuShell+import GI.Gtk.Objects.MenuShellAccessible+import GI.Gtk.Objects.MenuToolButton+import GI.Gtk.Objects.MessageDialog+import GI.Gtk.Objects.Misc+import GI.Gtk.Objects.ModelButton+import GI.Gtk.Objects.MountOperation+import GI.Gtk.Objects.Notebook+import GI.Gtk.Objects.NotebookAccessible+import GI.Gtk.Objects.NotebookPageAccessible+import GI.Gtk.Objects.NumerableIcon+import GI.Gtk.Objects.OffscreenWindow+import GI.Gtk.Objects.Overlay+import GI.Gtk.Objects.PageSetup+import GI.Gtk.Objects.Paned+import GI.Gtk.Objects.PanedAccessible+import GI.Gtk.Objects.PlacesSidebar+import GI.Gtk.Objects.Plug+import GI.Gtk.Objects.Popover+import GI.Gtk.Objects.PopoverAccessible+import GI.Gtk.Objects.PopoverMenu+import GI.Gtk.Objects.PrintContext+import GI.Gtk.Objects.PrintOperation+import GI.Gtk.Objects.PrintSettings+import GI.Gtk.Objects.ProgressBar+import GI.Gtk.Objects.ProgressBarAccessible+import GI.Gtk.Objects.RadioAction+import GI.Gtk.Objects.RadioButton+import GI.Gtk.Objects.RadioButtonAccessible+import GI.Gtk.Objects.RadioMenuItem+import GI.Gtk.Objects.RadioMenuItemAccessible+import GI.Gtk.Objects.RadioToolButton+import GI.Gtk.Objects.Range+import GI.Gtk.Objects.RangeAccessible+import GI.Gtk.Objects.RcStyle+import GI.Gtk.Objects.RecentAction+import GI.Gtk.Objects.RecentChooserDialog+import GI.Gtk.Objects.RecentChooserMenu+import GI.Gtk.Objects.RecentChooserWidget+import GI.Gtk.Objects.RecentFilter+import GI.Gtk.Objects.RecentManager+import GI.Gtk.Objects.RendererCellAccessible+import GI.Gtk.Objects.Revealer+import GI.Gtk.Objects.Scale+import GI.Gtk.Objects.ScaleAccessible+import GI.Gtk.Objects.ScaleButton+import GI.Gtk.Objects.ScaleButtonAccessible+import GI.Gtk.Objects.Scrollbar+import GI.Gtk.Objects.ScrolledWindow+import GI.Gtk.Objects.ScrolledWindowAccessible+import GI.Gtk.Objects.SearchBar+import GI.Gtk.Objects.SearchEntry+import GI.Gtk.Objects.Separator+import GI.Gtk.Objects.SeparatorMenuItem+import GI.Gtk.Objects.SeparatorToolItem+import GI.Gtk.Objects.Settings+import GI.Gtk.Objects.SizeGroup+import GI.Gtk.Objects.Socket+import GI.Gtk.Objects.SpinButton+import GI.Gtk.Objects.SpinButtonAccessible+import GI.Gtk.Objects.Spinner+import GI.Gtk.Objects.SpinnerAccessible+import GI.Gtk.Objects.Stack+import GI.Gtk.Objects.StackSidebar+import GI.Gtk.Objects.StackSwitcher+import GI.Gtk.Objects.StatusIcon+import GI.Gtk.Objects.Statusbar+import GI.Gtk.Objects.StatusbarAccessible+import GI.Gtk.Objects.Style+import GI.Gtk.Objects.StyleContext+import GI.Gtk.Objects.StyleProperties+import GI.Gtk.Objects.Switch+import GI.Gtk.Objects.SwitchAccessible+import GI.Gtk.Objects.Table+import GI.Gtk.Objects.TearoffMenuItem+import GI.Gtk.Objects.TextBuffer+import GI.Gtk.Objects.TextCellAccessible+import GI.Gtk.Objects.TextChildAnchor+import GI.Gtk.Objects.TextMark+import GI.Gtk.Objects.TextTag+import GI.Gtk.Objects.TextTagTable+import GI.Gtk.Objects.TextView+import GI.Gtk.Objects.TextViewAccessible+import GI.Gtk.Objects.ThemingEngine+import GI.Gtk.Objects.ToggleAction+import GI.Gtk.Objects.ToggleButton+import GI.Gtk.Objects.ToggleButtonAccessible+import GI.Gtk.Objects.ToggleToolButton+import GI.Gtk.Objects.ToolButton+import GI.Gtk.Objects.ToolItem+import GI.Gtk.Objects.ToolItemGroup+import GI.Gtk.Objects.ToolPalette+import GI.Gtk.Objects.Toolbar+import GI.Gtk.Objects.Tooltip+import GI.Gtk.Objects.ToplevelAccessible+import GI.Gtk.Objects.TreeModelFilter+import GI.Gtk.Objects.TreeModelSort+import GI.Gtk.Objects.TreeSelection+import GI.Gtk.Objects.TreeStore+import GI.Gtk.Objects.TreeView+import GI.Gtk.Objects.TreeViewAccessible+import GI.Gtk.Objects.TreeViewColumn+import GI.Gtk.Objects.UIManager+import GI.Gtk.Objects.VBox+import GI.Gtk.Objects.VButtonBox+import GI.Gtk.Objects.VPaned+import GI.Gtk.Objects.VScale+import GI.Gtk.Objects.VScrollbar+import GI.Gtk.Objects.VSeparator+import GI.Gtk.Objects.Viewport+import GI.Gtk.Objects.VolumeButton+import GI.Gtk.Objects.Widget+import GI.Gtk.Objects.WidgetAccessible+import GI.Gtk.Objects.Window+import GI.Gtk.Objects.WindowAccessible+import GI.Gtk.Objects.WindowGroup++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks++
+ GI/Gtk/Objects/AboutDialog.hs view
@@ -0,0 +1,1619 @@++{- |+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.Gtk.Objects.AboutDialog+    ( ++-- * Exported types+    AboutDialog(..)                         ,+    AboutDialogK                            ,+    toAboutDialog                           ,+    noAboutDialog                           ,+++ -- * Methods+-- ** aboutDialogAddCreditSection+    aboutDialogAddCreditSection             ,+++-- ** aboutDialogGetArtists+    aboutDialogGetArtists                   ,+++-- ** aboutDialogGetAuthors+    aboutDialogGetAuthors                   ,+++-- ** aboutDialogGetComments+    aboutDialogGetComments                  ,+++-- ** aboutDialogGetCopyright+    aboutDialogGetCopyright                 ,+++-- ** aboutDialogGetDocumenters+    aboutDialogGetDocumenters               ,+++-- ** aboutDialogGetLicense+    aboutDialogGetLicense                   ,+++-- ** aboutDialogGetLicenseType+    aboutDialogGetLicenseType               ,+++-- ** aboutDialogGetLogo+    aboutDialogGetLogo                      ,+++-- ** aboutDialogGetLogoIconName+    aboutDialogGetLogoIconName              ,+++-- ** aboutDialogGetProgramName+    aboutDialogGetProgramName               ,+++-- ** aboutDialogGetTranslatorCredits+    aboutDialogGetTranslatorCredits         ,+++-- ** aboutDialogGetVersion+    aboutDialogGetVersion                   ,+++-- ** aboutDialogGetWebsite+    aboutDialogGetWebsite                   ,+++-- ** aboutDialogGetWebsiteLabel+    aboutDialogGetWebsiteLabel              ,+++-- ** aboutDialogGetWrapLicense+    aboutDialogGetWrapLicense               ,+++-- ** aboutDialogNew+    aboutDialogNew                          ,+++-- ** aboutDialogSetArtists+    aboutDialogSetArtists                   ,+++-- ** aboutDialogSetAuthors+    aboutDialogSetAuthors                   ,+++-- ** aboutDialogSetComments+    aboutDialogSetComments                  ,+++-- ** aboutDialogSetCopyright+    aboutDialogSetCopyright                 ,+++-- ** aboutDialogSetDocumenters+    aboutDialogSetDocumenters               ,+++-- ** aboutDialogSetLicense+    aboutDialogSetLicense                   ,+++-- ** aboutDialogSetLicenseType+    aboutDialogSetLicenseType               ,+++-- ** aboutDialogSetLogo+    aboutDialogSetLogo                      ,+++-- ** aboutDialogSetLogoIconName+    aboutDialogSetLogoIconName              ,+++-- ** aboutDialogSetProgramName+    aboutDialogSetProgramName               ,+++-- ** aboutDialogSetTranslatorCredits+    aboutDialogSetTranslatorCredits         ,+++-- ** aboutDialogSetVersion+    aboutDialogSetVersion                   ,+++-- ** aboutDialogSetWebsite+    aboutDialogSetWebsite                   ,+++-- ** aboutDialogSetWebsiteLabel+    aboutDialogSetWebsiteLabel              ,+++-- ** aboutDialogSetWrapLicense+    aboutDialogSetWrapLicense               ,+++++ -- * Properties+-- ** Artists+    AboutDialogArtistsPropertyInfo          ,+    constructAboutDialogArtists             ,+    getAboutDialogArtists                   ,+    setAboutDialogArtists                   ,+++-- ** Authors+    AboutDialogAuthorsPropertyInfo          ,+    constructAboutDialogAuthors             ,+    getAboutDialogAuthors                   ,+    setAboutDialogAuthors                   ,+++-- ** Comments+    AboutDialogCommentsPropertyInfo         ,+    constructAboutDialogComments            ,+    getAboutDialogComments                  ,+    setAboutDialogComments                  ,+++-- ** Copyright+    AboutDialogCopyrightPropertyInfo        ,+    constructAboutDialogCopyright           ,+    getAboutDialogCopyright                 ,+    setAboutDialogCopyright                 ,+++-- ** Documenters+    AboutDialogDocumentersPropertyInfo      ,+    constructAboutDialogDocumenters         ,+    getAboutDialogDocumenters               ,+    setAboutDialogDocumenters               ,+++-- ** License+    AboutDialogLicensePropertyInfo          ,+    constructAboutDialogLicense             ,+    getAboutDialogLicense                   ,+    setAboutDialogLicense                   ,+++-- ** LicenseType+    AboutDialogLicenseTypePropertyInfo      ,+    constructAboutDialogLicenseType         ,+    getAboutDialogLicenseType               ,+    setAboutDialogLicenseType               ,+++-- ** Logo+    AboutDialogLogoPropertyInfo             ,+    constructAboutDialogLogo                ,+    getAboutDialogLogo                      ,+    setAboutDialogLogo                      ,+++-- ** LogoIconName+    AboutDialogLogoIconNamePropertyInfo     ,+    constructAboutDialogLogoIconName        ,+    getAboutDialogLogoIconName              ,+    setAboutDialogLogoIconName              ,+++-- ** ProgramName+    AboutDialogProgramNamePropertyInfo      ,+    constructAboutDialogProgramName         ,+    getAboutDialogProgramName               ,+    setAboutDialogProgramName               ,+++-- ** TranslatorCredits+    AboutDialogTranslatorCreditsPropertyInfo,+    constructAboutDialogTranslatorCredits   ,+    getAboutDialogTranslatorCredits         ,+    setAboutDialogTranslatorCredits         ,+++-- ** Version+    AboutDialogVersionPropertyInfo          ,+    constructAboutDialogVersion             ,+    getAboutDialogVersion                   ,+    setAboutDialogVersion                   ,+++-- ** Website+    AboutDialogWebsitePropertyInfo          ,+    constructAboutDialogWebsite             ,+    getAboutDialogWebsite                   ,+    setAboutDialogWebsite                   ,+++-- ** WebsiteLabel+    AboutDialogWebsiteLabelPropertyInfo     ,+    constructAboutDialogWebsiteLabel        ,+    getAboutDialogWebsiteLabel              ,+    setAboutDialogWebsiteLabel              ,+++-- ** WrapLicense+    AboutDialogWrapLicensePropertyInfo      ,+    constructAboutDialogWrapLicense         ,+    getAboutDialogWrapLicense               ,+    setAboutDialogWrapLicense               ,+++++ -- * Signals+-- ** ActivateLink+    AboutDialogActivateLinkCallback         ,+    AboutDialogActivateLinkCallbackC        ,+    AboutDialogActivateLinkSignalInfo       ,+    aboutDialogActivateLinkCallbackWrapper  ,+    aboutDialogActivateLinkClosure          ,+    afterAboutDialogActivateLink            ,+    mkAboutDialogActivateLinkCallback       ,+    noAboutDialogActivateLinkCallback       ,+    onAboutDialogActivateLink               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.GdkPixbuf as GdkPixbuf++newtype AboutDialog = AboutDialog (ForeignPtr AboutDialog)+foreign import ccall "gtk_about_dialog_get_type"+    c_gtk_about_dialog_get_type :: IO GType++type instance ParentTypes AboutDialog = AboutDialogParentTypes+type AboutDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject AboutDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_about_dialog_get_type+    ++class GObject o => AboutDialogK o+instance (GObject o, IsDescendantOf AboutDialog o) => AboutDialogK o++toAboutDialog :: AboutDialogK o => o -> IO AboutDialog+toAboutDialog = unsafeCastTo AboutDialog++noAboutDialog :: Maybe AboutDialog+noAboutDialog = Nothing++-- signal AboutDialog::activate-link+type AboutDialogActivateLinkCallback =+    T.Text ->+    IO Bool++noAboutDialogActivateLinkCallback :: Maybe AboutDialogActivateLinkCallback+noAboutDialogActivateLinkCallback = Nothing++type AboutDialogActivateLinkCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkAboutDialogActivateLinkCallback :: AboutDialogActivateLinkCallbackC -> IO (FunPtr AboutDialogActivateLinkCallbackC)++aboutDialogActivateLinkClosure :: AboutDialogActivateLinkCallback -> IO Closure+aboutDialogActivateLinkClosure cb = newCClosure =<< mkAboutDialogActivateLinkCallback wrapped+    where wrapped = aboutDialogActivateLinkCallbackWrapper cb++aboutDialogActivateLinkCallbackWrapper ::+    AboutDialogActivateLinkCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO CInt+aboutDialogActivateLinkCallbackWrapper _cb _ uri _ = do+    uri' <- cstringToText uri+    result <- _cb  uri'+    let result' = (fromIntegral . fromEnum) result+    return result'++onAboutDialogActivateLink :: (GObject a, MonadIO m) => a -> AboutDialogActivateLinkCallback -> m SignalHandlerId+onAboutDialogActivateLink obj cb = liftIO $ connectAboutDialogActivateLink obj cb SignalConnectBefore+afterAboutDialogActivateLink :: (GObject a, MonadIO m) => a -> AboutDialogActivateLinkCallback -> m SignalHandlerId+afterAboutDialogActivateLink obj cb = connectAboutDialogActivateLink obj cb SignalConnectAfter++connectAboutDialogActivateLink :: (GObject a, MonadIO m) =>+                                  a -> AboutDialogActivateLinkCallback -> SignalConnectMode -> m SignalHandlerId+connectAboutDialogActivateLink obj cb after = liftIO $ do+    cb' <- mkAboutDialogActivateLinkCallback (aboutDialogActivateLinkCallbackWrapper cb)+    connectSignalFunPtr obj "activate-link" cb' after++-- VVV Prop "artists"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogArtists :: (MonadIO m, AboutDialogK o) => o -> m [T.Text]+getAboutDialogArtists obj = liftIO $ getObjectPropertyStringArray obj "artists"++setAboutDialogArtists :: (MonadIO m, AboutDialogK o) => o -> [T.Text] -> m ()+setAboutDialogArtists obj val = liftIO $ setObjectPropertyStringArray obj "artists" val++constructAboutDialogArtists :: [T.Text] -> IO ([Char], GValue)+constructAboutDialogArtists val = constructObjectPropertyStringArray "artists" val++data AboutDialogArtistsPropertyInfo+instance AttrInfo AboutDialogArtistsPropertyInfo where+    type AttrAllowedOps AboutDialogArtistsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogArtistsPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint AboutDialogArtistsPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogArtistsPropertyInfo = [T.Text]+    type AttrLabel AboutDialogArtistsPropertyInfo = "AboutDialog::artists"+    attrGet _ = getAboutDialogArtists+    attrSet _ = setAboutDialogArtists+    attrConstruct _ = constructAboutDialogArtists++-- VVV Prop "authors"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogAuthors :: (MonadIO m, AboutDialogK o) => o -> m [T.Text]+getAboutDialogAuthors obj = liftIO $ getObjectPropertyStringArray obj "authors"++setAboutDialogAuthors :: (MonadIO m, AboutDialogK o) => o -> [T.Text] -> m ()+setAboutDialogAuthors obj val = liftIO $ setObjectPropertyStringArray obj "authors" val++constructAboutDialogAuthors :: [T.Text] -> IO ([Char], GValue)+constructAboutDialogAuthors val = constructObjectPropertyStringArray "authors" val++data AboutDialogAuthorsPropertyInfo+instance AttrInfo AboutDialogAuthorsPropertyInfo where+    type AttrAllowedOps AboutDialogAuthorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogAuthorsPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint AboutDialogAuthorsPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogAuthorsPropertyInfo = [T.Text]+    type AttrLabel AboutDialogAuthorsPropertyInfo = "AboutDialog::authors"+    attrGet _ = getAboutDialogAuthors+    attrSet _ = setAboutDialogAuthors+    attrConstruct _ = constructAboutDialogAuthors++-- VVV Prop "comments"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogComments :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogComments obj = liftIO $ getObjectPropertyString obj "comments"++setAboutDialogComments :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogComments obj val = liftIO $ setObjectPropertyString obj "comments" val++constructAboutDialogComments :: T.Text -> IO ([Char], GValue)+constructAboutDialogComments val = constructObjectPropertyString "comments" val++data AboutDialogCommentsPropertyInfo+instance AttrInfo AboutDialogCommentsPropertyInfo where+    type AttrAllowedOps AboutDialogCommentsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogCommentsPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogCommentsPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogCommentsPropertyInfo = T.Text+    type AttrLabel AboutDialogCommentsPropertyInfo = "AboutDialog::comments"+    attrGet _ = getAboutDialogComments+    attrSet _ = setAboutDialogComments+    attrConstruct _ = constructAboutDialogComments++-- VVV Prop "copyright"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogCopyright :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogCopyright obj = liftIO $ getObjectPropertyString obj "copyright"++setAboutDialogCopyright :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogCopyright obj val = liftIO $ setObjectPropertyString obj "copyright" val++constructAboutDialogCopyright :: T.Text -> IO ([Char], GValue)+constructAboutDialogCopyright val = constructObjectPropertyString "copyright" val++data AboutDialogCopyrightPropertyInfo+instance AttrInfo AboutDialogCopyrightPropertyInfo where+    type AttrAllowedOps AboutDialogCopyrightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogCopyrightPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogCopyrightPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogCopyrightPropertyInfo = T.Text+    type AttrLabel AboutDialogCopyrightPropertyInfo = "AboutDialog::copyright"+    attrGet _ = getAboutDialogCopyright+    attrSet _ = setAboutDialogCopyright+    attrConstruct _ = constructAboutDialogCopyright++-- VVV Prop "documenters"+   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogDocumenters :: (MonadIO m, AboutDialogK o) => o -> m [T.Text]+getAboutDialogDocumenters obj = liftIO $ getObjectPropertyStringArray obj "documenters"++setAboutDialogDocumenters :: (MonadIO m, AboutDialogK o) => o -> [T.Text] -> m ()+setAboutDialogDocumenters obj val = liftIO $ setObjectPropertyStringArray obj "documenters" val++constructAboutDialogDocumenters :: [T.Text] -> IO ([Char], GValue)+constructAboutDialogDocumenters val = constructObjectPropertyStringArray "documenters" val++data AboutDialogDocumentersPropertyInfo+instance AttrInfo AboutDialogDocumentersPropertyInfo where+    type AttrAllowedOps AboutDialogDocumentersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogDocumentersPropertyInfo = (~) [T.Text]+    type AttrBaseTypeConstraint AboutDialogDocumentersPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogDocumentersPropertyInfo = [T.Text]+    type AttrLabel AboutDialogDocumentersPropertyInfo = "AboutDialog::documenters"+    attrGet _ = getAboutDialogDocumenters+    attrSet _ = setAboutDialogDocumenters+    attrConstruct _ = constructAboutDialogDocumenters++-- VVV Prop "license"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogLicense :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogLicense obj = liftIO $ getObjectPropertyString obj "license"++setAboutDialogLicense :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogLicense obj val = liftIO $ setObjectPropertyString obj "license" val++constructAboutDialogLicense :: T.Text -> IO ([Char], GValue)+constructAboutDialogLicense val = constructObjectPropertyString "license" val++data AboutDialogLicensePropertyInfo+instance AttrInfo AboutDialogLicensePropertyInfo where+    type AttrAllowedOps AboutDialogLicensePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogLicensePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogLicensePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogLicensePropertyInfo = T.Text+    type AttrLabel AboutDialogLicensePropertyInfo = "AboutDialog::license"+    attrGet _ = getAboutDialogLicense+    attrSet _ = setAboutDialogLicense+    attrConstruct _ = constructAboutDialogLicense++-- VVV Prop "license-type"+   -- Type: TInterface "Gtk" "License"+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogLicenseType :: (MonadIO m, AboutDialogK o) => o -> m License+getAboutDialogLicenseType obj = liftIO $ getObjectPropertyEnum obj "license-type"++setAboutDialogLicenseType :: (MonadIO m, AboutDialogK o) => o -> License -> m ()+setAboutDialogLicenseType obj val = liftIO $ setObjectPropertyEnum obj "license-type" val++constructAboutDialogLicenseType :: License -> IO ([Char], GValue)+constructAboutDialogLicenseType val = constructObjectPropertyEnum "license-type" val++data AboutDialogLicenseTypePropertyInfo+instance AttrInfo AboutDialogLicenseTypePropertyInfo where+    type AttrAllowedOps AboutDialogLicenseTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogLicenseTypePropertyInfo = (~) License+    type AttrBaseTypeConstraint AboutDialogLicenseTypePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogLicenseTypePropertyInfo = License+    type AttrLabel AboutDialogLicenseTypePropertyInfo = "AboutDialog::license-type"+    attrGet _ = getAboutDialogLicenseType+    attrSet _ = setAboutDialogLicenseType+    attrConstruct _ = constructAboutDialogLicenseType++-- VVV Prop "logo"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogLogo :: (MonadIO m, AboutDialogK o) => o -> m GdkPixbuf.Pixbuf+getAboutDialogLogo obj = liftIO $ getObjectPropertyObject obj "logo" GdkPixbuf.Pixbuf++setAboutDialogLogo :: (MonadIO m, AboutDialogK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setAboutDialogLogo obj val = liftIO $ setObjectPropertyObject obj "logo" val++constructAboutDialogLogo :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructAboutDialogLogo val = constructObjectPropertyObject "logo" val++data AboutDialogLogoPropertyInfo+instance AttrInfo AboutDialogLogoPropertyInfo where+    type AttrAllowedOps AboutDialogLogoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogLogoPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint AboutDialogLogoPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogLogoPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel AboutDialogLogoPropertyInfo = "AboutDialog::logo"+    attrGet _ = getAboutDialogLogo+    attrSet _ = setAboutDialogLogo+    attrConstruct _ = constructAboutDialogLogo++-- VVV Prop "logo-icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogLogoIconName :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogLogoIconName obj = liftIO $ getObjectPropertyString obj "logo-icon-name"++setAboutDialogLogoIconName :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogLogoIconName obj val = liftIO $ setObjectPropertyString obj "logo-icon-name" val++constructAboutDialogLogoIconName :: T.Text -> IO ([Char], GValue)+constructAboutDialogLogoIconName val = constructObjectPropertyString "logo-icon-name" val++data AboutDialogLogoIconNamePropertyInfo+instance AttrInfo AboutDialogLogoIconNamePropertyInfo where+    type AttrAllowedOps AboutDialogLogoIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogLogoIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogLogoIconNamePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogLogoIconNamePropertyInfo = T.Text+    type AttrLabel AboutDialogLogoIconNamePropertyInfo = "AboutDialog::logo-icon-name"+    attrGet _ = getAboutDialogLogoIconName+    attrSet _ = setAboutDialogLogoIconName+    attrConstruct _ = constructAboutDialogLogoIconName++-- VVV Prop "program-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogProgramName :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogProgramName obj = liftIO $ getObjectPropertyString obj "program-name"++setAboutDialogProgramName :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogProgramName obj val = liftIO $ setObjectPropertyString obj "program-name" val++constructAboutDialogProgramName :: T.Text -> IO ([Char], GValue)+constructAboutDialogProgramName val = constructObjectPropertyString "program-name" val++data AboutDialogProgramNamePropertyInfo+instance AttrInfo AboutDialogProgramNamePropertyInfo where+    type AttrAllowedOps AboutDialogProgramNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogProgramNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogProgramNamePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogProgramNamePropertyInfo = T.Text+    type AttrLabel AboutDialogProgramNamePropertyInfo = "AboutDialog::program-name"+    attrGet _ = getAboutDialogProgramName+    attrSet _ = setAboutDialogProgramName+    attrConstruct _ = constructAboutDialogProgramName++-- VVV Prop "translator-credits"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogTranslatorCredits :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogTranslatorCredits obj = liftIO $ getObjectPropertyString obj "translator-credits"++setAboutDialogTranslatorCredits :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogTranslatorCredits obj val = liftIO $ setObjectPropertyString obj "translator-credits" val++constructAboutDialogTranslatorCredits :: T.Text -> IO ([Char], GValue)+constructAboutDialogTranslatorCredits val = constructObjectPropertyString "translator-credits" val++data AboutDialogTranslatorCreditsPropertyInfo+instance AttrInfo AboutDialogTranslatorCreditsPropertyInfo where+    type AttrAllowedOps AboutDialogTranslatorCreditsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogTranslatorCreditsPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogTranslatorCreditsPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogTranslatorCreditsPropertyInfo = T.Text+    type AttrLabel AboutDialogTranslatorCreditsPropertyInfo = "AboutDialog::translator-credits"+    attrGet _ = getAboutDialogTranslatorCredits+    attrSet _ = setAboutDialogTranslatorCredits+    attrConstruct _ = constructAboutDialogTranslatorCredits++-- VVV Prop "version"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogVersion :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogVersion obj = liftIO $ getObjectPropertyString obj "version"++setAboutDialogVersion :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogVersion obj val = liftIO $ setObjectPropertyString obj "version" val++constructAboutDialogVersion :: T.Text -> IO ([Char], GValue)+constructAboutDialogVersion val = constructObjectPropertyString "version" val++data AboutDialogVersionPropertyInfo+instance AttrInfo AboutDialogVersionPropertyInfo where+    type AttrAllowedOps AboutDialogVersionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogVersionPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogVersionPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogVersionPropertyInfo = T.Text+    type AttrLabel AboutDialogVersionPropertyInfo = "AboutDialog::version"+    attrGet _ = getAboutDialogVersion+    attrSet _ = setAboutDialogVersion+    attrConstruct _ = constructAboutDialogVersion++-- VVV Prop "website"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogWebsite :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogWebsite obj = liftIO $ getObjectPropertyString obj "website"++setAboutDialogWebsite :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogWebsite obj val = liftIO $ setObjectPropertyString obj "website" val++constructAboutDialogWebsite :: T.Text -> IO ([Char], GValue)+constructAboutDialogWebsite val = constructObjectPropertyString "website" val++data AboutDialogWebsitePropertyInfo+instance AttrInfo AboutDialogWebsitePropertyInfo where+    type AttrAllowedOps AboutDialogWebsitePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogWebsitePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogWebsitePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogWebsitePropertyInfo = T.Text+    type AttrLabel AboutDialogWebsitePropertyInfo = "AboutDialog::website"+    attrGet _ = getAboutDialogWebsite+    attrSet _ = setAboutDialogWebsite+    attrConstruct _ = constructAboutDialogWebsite++-- VVV Prop "website-label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogWebsiteLabel :: (MonadIO m, AboutDialogK o) => o -> m T.Text+getAboutDialogWebsiteLabel obj = liftIO $ getObjectPropertyString obj "website-label"++setAboutDialogWebsiteLabel :: (MonadIO m, AboutDialogK o) => o -> T.Text -> m ()+setAboutDialogWebsiteLabel obj val = liftIO $ setObjectPropertyString obj "website-label" val++constructAboutDialogWebsiteLabel :: T.Text -> IO ([Char], GValue)+constructAboutDialogWebsiteLabel val = constructObjectPropertyString "website-label" val++data AboutDialogWebsiteLabelPropertyInfo+instance AttrInfo AboutDialogWebsiteLabelPropertyInfo where+    type AttrAllowedOps AboutDialogWebsiteLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogWebsiteLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AboutDialogWebsiteLabelPropertyInfo = AboutDialogK+    type AttrGetType AboutDialogWebsiteLabelPropertyInfo = T.Text+    type AttrLabel AboutDialogWebsiteLabelPropertyInfo = "AboutDialog::website-label"+    attrGet _ = getAboutDialogWebsiteLabel+    attrSet _ = setAboutDialogWebsiteLabel+    attrConstruct _ = constructAboutDialogWebsiteLabel++-- VVV Prop "wrap-license"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getAboutDialogWrapLicense :: (MonadIO m, AboutDialogK o) => o -> m Bool+getAboutDialogWrapLicense obj = liftIO $ getObjectPropertyBool obj "wrap-license"++setAboutDialogWrapLicense :: (MonadIO m, AboutDialogK o) => o -> Bool -> m ()+setAboutDialogWrapLicense obj val = liftIO $ setObjectPropertyBool obj "wrap-license" val++constructAboutDialogWrapLicense :: Bool -> IO ([Char], GValue)+constructAboutDialogWrapLicense val = constructObjectPropertyBool "wrap-license" val++data AboutDialogWrapLicensePropertyInfo+instance AttrInfo AboutDialogWrapLicensePropertyInfo where+    type AttrAllowedOps AboutDialogWrapLicensePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AboutDialogWrapLicensePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AboutDialogWrapLicensePropertyInfo = AboutDialogK+    type AttrGetType AboutDialogWrapLicensePropertyInfo = Bool+    type AttrLabel AboutDialogWrapLicensePropertyInfo = "AboutDialog::wrap-license"+    attrGet _ = getAboutDialogWrapLicense+    attrSet _ = setAboutDialogWrapLicense+    attrConstruct _ = constructAboutDialogWrapLicense++type instance AttributeList AboutDialog = AboutDialogAttributeList+type AboutDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("artists", AboutDialogArtistsPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("authors", AboutDialogAuthorsPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("comments", AboutDialogCommentsPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("copyright", AboutDialogCopyrightPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("documenters", AboutDialogDocumentersPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("license", AboutDialogLicensePropertyInfo), '("license-type", AboutDialogLicenseTypePropertyInfo), '("logo", AboutDialogLogoPropertyInfo), '("logo-icon-name", AboutDialogLogoIconNamePropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("program-name", AboutDialogProgramNamePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("translator-credits", AboutDialogTranslatorCreditsPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("version", AboutDialogVersionPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("website", AboutDialogWebsitePropertyInfo), '("website-label", AboutDialogWebsiteLabelPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo), '("wrap-license", AboutDialogWrapLicensePropertyInfo)] :: [(Symbol, *)])++data AboutDialogActivateLinkSignalInfo+instance SignalInfo AboutDialogActivateLinkSignalInfo where+    type HaskellCallbackType AboutDialogActivateLinkSignalInfo = AboutDialogActivateLinkCallback+    connectSignal _ = connectAboutDialogActivateLink++type instance SignalList AboutDialog = AboutDialogSignalList+type AboutDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("activate-link", AboutDialogActivateLinkSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AboutDialog::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "AboutDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_new" gtk_about_dialog_new :: +    IO (Ptr AboutDialog)+++aboutDialogNew ::+    (MonadIO m) =>+    m AboutDialog+aboutDialogNew  = liftIO $ do+    result <- gtk_about_dialog_new+    checkUnexpectedReturnNULL "gtk_about_dialog_new" result+    result' <- (newObject AboutDialog) result+    return result'++-- method AboutDialog::add_credit_section+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "people", 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 "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "section_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "people", argType = TCArray True (-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 "gtk_about_dialog_add_credit_section" gtk_about_dialog_add_credit_section :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- section_name : TBasicType TUTF8+    Ptr CString ->                          -- people : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++aboutDialogAddCreditSection ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- section_name+    [T.Text] ->                             -- people+    m ()+aboutDialogAddCreditSection _obj section_name people = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    section_name' <- textToCString section_name+    people' <- packZeroTerminatedUTF8CArray people+    gtk_about_dialog_add_credit_section _obj' section_name' people'+    touchManagedPtr _obj+    freeMem section_name'+    mapZeroTerminatedCArray freeMem people'+    freeMem people'+    return ()++-- method AboutDialog::get_artists+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", 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 "gtk_about_dialog_get_artists" gtk_about_dialog_get_artists :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO (Ptr CString)+++aboutDialogGetArtists ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m [T.Text]+aboutDialogGetArtists _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_artists _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_artists" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_authors+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", 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 "gtk_about_dialog_get_authors" gtk_about_dialog_get_authors :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO (Ptr CString)+++aboutDialogGetAuthors ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m [T.Text]+aboutDialogGetAuthors _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_authors _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_authors" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_comments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_comments" gtk_about_dialog_get_comments :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetComments ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetComments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_comments _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_comments" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_copyright+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_copyright" gtk_about_dialog_get_copyright :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetCopyright ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetCopyright _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_copyright _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_copyright" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_documenters+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", 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 "gtk_about_dialog_get_documenters" gtk_about_dialog_get_documenters :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO (Ptr CString)+++aboutDialogGetDocumenters ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m [T.Text]+aboutDialogGetDocumenters _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_documenters _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_documenters" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_license+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_license" gtk_about_dialog_get_license :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetLicense ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetLicense _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_license _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_license" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_license_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "License"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_license_type" gtk_about_dialog_get_license_type :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CUInt+++aboutDialogGetLicenseType ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m License+aboutDialogGetLicenseType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_license_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_logo+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_logo" gtk_about_dialog_get_logo :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO (Ptr GdkPixbuf.Pixbuf)+++aboutDialogGetLogo ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+aboutDialogGetLogo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_logo _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_logo" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_logo_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_logo_icon_name" gtk_about_dialog_get_logo_icon_name :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetLogoIconName ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetLogoIconName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_logo_icon_name _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_logo_icon_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_program_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_program_name" gtk_about_dialog_get_program_name :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetProgramName ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetProgramName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_program_name _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_program_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_translator_credits+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_translator_credits" gtk_about_dialog_get_translator_credits :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetTranslatorCredits ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetTranslatorCredits _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_translator_credits _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_translator_credits" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_version+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_version" gtk_about_dialog_get_version :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetVersion ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetVersion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_version _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_version" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_website+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_website" gtk_about_dialog_get_website :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetWebsite ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetWebsite _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_website _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_website" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_website_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_website_label" gtk_about_dialog_get_website_label :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CString+++aboutDialogGetWebsiteLabel ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m T.Text+aboutDialogGetWebsiteLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_website_label _obj'+    checkUnexpectedReturnNULL "gtk_about_dialog_get_website_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::get_wrap_license+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_get_wrap_license" gtk_about_dialog_get_wrap_license :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    IO CInt+++aboutDialogGetWrapLicense ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    m Bool+aboutDialogGetWrapLicense _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_about_dialog_get_wrap_license _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AboutDialog::set_artists+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "artists", 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 "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "artists", argType = TCArray True (-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 "gtk_about_dialog_set_artists" gtk_about_dialog_set_artists :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    Ptr CString ->                          -- artists : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++aboutDialogSetArtists ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- artists+    m ()+aboutDialogSetArtists _obj artists = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    artists' <- packZeroTerminatedUTF8CArray artists+    gtk_about_dialog_set_artists _obj' artists'+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem artists'+    freeMem artists'+    return ()++-- method AboutDialog::set_authors+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "authors", 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 "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "authors", argType = TCArray True (-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 "gtk_about_dialog_set_authors" gtk_about_dialog_set_authors :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    Ptr CString ->                          -- authors : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++aboutDialogSetAuthors ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- authors+    m ()+aboutDialogSetAuthors _obj authors = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    authors' <- packZeroTerminatedUTF8CArray authors+    gtk_about_dialog_set_authors _obj' authors'+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem authors'+    freeMem authors'+    return ()++-- method AboutDialog::set_comments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "comments", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "comments", 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 "gtk_about_dialog_set_comments" gtk_about_dialog_set_comments :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- comments : TBasicType TUTF8+    IO ()+++aboutDialogSetComments ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- comments+    m ()+aboutDialogSetComments _obj comments = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeComments <- case comments of+        Nothing -> return nullPtr+        Just jComments -> do+            jComments' <- textToCString jComments+            return jComments'+    gtk_about_dialog_set_comments _obj' maybeComments+    touchManagedPtr _obj+    freeMem maybeComments+    return ()++-- method AboutDialog::set_copyright+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "copyright", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "copyright", 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 "gtk_about_dialog_set_copyright" gtk_about_dialog_set_copyright :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- copyright : TBasicType TUTF8+    IO ()+++aboutDialogSetCopyright ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- copyright+    m ()+aboutDialogSetCopyright _obj copyright = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCopyright <- case copyright of+        Nothing -> return nullPtr+        Just jCopyright -> do+            jCopyright' <- textToCString jCopyright+            return jCopyright'+    gtk_about_dialog_set_copyright _obj' maybeCopyright+    touchManagedPtr _obj+    freeMem maybeCopyright+    return ()++-- method AboutDialog::set_documenters+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "documenters", 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 "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "documenters", argType = TCArray True (-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 "gtk_about_dialog_set_documenters" gtk_about_dialog_set_documenters :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    Ptr CString ->                          -- documenters : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++aboutDialogSetDocumenters ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- documenters+    m ()+aboutDialogSetDocumenters _obj documenters = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    documenters' <- packZeroTerminatedUTF8CArray documenters+    gtk_about_dialog_set_documenters _obj' documenters'+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem documenters'+    freeMem documenters'+    return ()++-- method AboutDialog::set_license+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "license", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "license", 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 "gtk_about_dialog_set_license" gtk_about_dialog_set_license :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- license : TBasicType TUTF8+    IO ()+++aboutDialogSetLicense ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- license+    m ()+aboutDialogSetLicense _obj license = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLicense <- case license of+        Nothing -> return nullPtr+        Just jLicense -> do+            jLicense' <- textToCString jLicense+            return jLicense'+    gtk_about_dialog_set_license _obj' maybeLicense+    touchManagedPtr _obj+    freeMem maybeLicense+    return ()++-- method AboutDialog::set_license_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "license_type", argType = TInterface "Gtk" "License", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "license_type", argType = TInterface "Gtk" "License", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_set_license_type" gtk_about_dialog_set_license_type :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CUInt ->                                -- license_type : TInterface "Gtk" "License"+    IO ()+++aboutDialogSetLicenseType ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    License ->                              -- license_type+    m ()+aboutDialogSetLicenseType _obj license_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let license_type' = (fromIntegral . fromEnum) license_type+    gtk_about_dialog_set_license_type _obj' license_type'+    touchManagedPtr _obj+    return ()++-- method AboutDialog::set_logo+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "logo", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "logo", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_about_dialog_set_logo" gtk_about_dialog_set_logo :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    Ptr GdkPixbuf.Pixbuf ->                 -- logo : TInterface "GdkPixbuf" "Pixbuf"+    IO ()+++aboutDialogSetLogo ::+    (MonadIO m, AboutDialogK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- logo+    m ()+aboutDialogSetLogo _obj logo = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLogo <- case logo of+        Nothing -> return nullPtr+        Just jLogo -> do+            let jLogo' = unsafeManagedPtrCastPtr jLogo+            return jLogo'+    gtk_about_dialog_set_logo _obj' maybeLogo+    touchManagedPtr _obj+    whenJust logo touchManagedPtr+    return ()++-- method AboutDialog::set_logo_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", 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 "gtk_about_dialog_set_logo_icon_name" gtk_about_dialog_set_logo_icon_name :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO ()+++aboutDialogSetLogoIconName ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- icon_name+    m ()+aboutDialogSetLogoIconName _obj icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIcon_name <- case icon_name of+        Nothing -> return nullPtr+        Just jIcon_name -> do+            jIcon_name' <- textToCString jIcon_name+            return jIcon_name'+    gtk_about_dialog_set_logo_icon_name _obj' maybeIcon_name+    touchManagedPtr _obj+    freeMem maybeIcon_name+    return ()++-- method AboutDialog::set_program_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", 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 "Gtk" "AboutDialog", 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 "gtk_about_dialog_set_program_name" gtk_about_dialog_set_program_name :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++aboutDialogSetProgramName ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m ()+aboutDialogSetProgramName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gtk_about_dialog_set_program_name _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method AboutDialog::set_translator_credits+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "translator_credits", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "translator_credits", 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 "gtk_about_dialog_set_translator_credits" gtk_about_dialog_set_translator_credits :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- translator_credits : TBasicType TUTF8+    IO ()+++aboutDialogSetTranslatorCredits ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- translator_credits+    m ()+aboutDialogSetTranslatorCredits _obj translator_credits = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTranslator_credits <- case translator_credits of+        Nothing -> return nullPtr+        Just jTranslator_credits -> do+            jTranslator_credits' <- textToCString jTranslator_credits+            return jTranslator_credits'+    gtk_about_dialog_set_translator_credits _obj' maybeTranslator_credits+    touchManagedPtr _obj+    freeMem maybeTranslator_credits+    return ()++-- method AboutDialog::set_version+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "version", 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 "gtk_about_dialog_set_version" gtk_about_dialog_set_version :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- version : TBasicType TUTF8+    IO ()+++aboutDialogSetVersion ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- version+    m ()+aboutDialogSetVersion _obj version = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeVersion <- case version of+        Nothing -> return nullPtr+        Just jVersion -> do+            jVersion' <- textToCString jVersion+            return jVersion'+    gtk_about_dialog_set_version _obj' maybeVersion+    touchManagedPtr _obj+    freeMem maybeVersion+    return ()++-- method AboutDialog::set_website+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "website", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "website", 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 "gtk_about_dialog_set_website" gtk_about_dialog_set_website :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- website : TBasicType TUTF8+    IO ()+++aboutDialogSetWebsite ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- website+    m ()+aboutDialogSetWebsite _obj website = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWebsite <- case website of+        Nothing -> return nullPtr+        Just jWebsite -> do+            jWebsite' <- textToCString jWebsite+            return jWebsite'+    gtk_about_dialog_set_website _obj' maybeWebsite+    touchManagedPtr _obj+    freeMem maybeWebsite+    return ()++-- method AboutDialog::set_website_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "website_label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "website_label", 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 "gtk_about_dialog_set_website_label" gtk_about_dialog_set_website_label :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CString ->                              -- website_label : TBasicType TUTF8+    IO ()+++aboutDialogSetWebsiteLabel ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- website_label+    m ()+aboutDialogSetWebsiteLabel _obj website_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    website_label' <- textToCString website_label+    gtk_about_dialog_set_website_label _obj' website_label'+    touchManagedPtr _obj+    freeMem website_label'+    return ()++-- method AboutDialog::set_wrap_license+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_license", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AboutDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_license", 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 "gtk_about_dialog_set_wrap_license" gtk_about_dialog_set_wrap_license :: +    Ptr AboutDialog ->                      -- _obj : TInterface "Gtk" "AboutDialog"+    CInt ->                                 -- wrap_license : TBasicType TBoolean+    IO ()+++aboutDialogSetWrapLicense ::+    (MonadIO m, AboutDialogK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- wrap_license+    m ()+aboutDialogSetWrapLicense _obj wrap_license = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let wrap_license' = (fromIntegral . fromEnum) wrap_license+    gtk_about_dialog_set_wrap_license _obj' wrap_license'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/AboutDialog.hs-boot view
@@ -0,0 +1,29 @@+module GI.Gtk.Objects.AboutDialog where++import Prelude ()+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 AboutDialog = AboutDialog (ForeignPtr AboutDialog)+instance GObject AboutDialog where+class GObject o => AboutDialogK o+instance (GObject o, IsDescendantOf AboutDialog o) => AboutDialogK o+data AboutDialogArtistsPropertyInfo+data AboutDialogAuthorsPropertyInfo+data AboutDialogCommentsPropertyInfo+data AboutDialogCopyrightPropertyInfo+data AboutDialogDocumentersPropertyInfo+data AboutDialogLicensePropertyInfo+data AboutDialogLicenseTypePropertyInfo+data AboutDialogLogoPropertyInfo+data AboutDialogLogoIconNamePropertyInfo+data AboutDialogProgramNamePropertyInfo+data AboutDialogTranslatorCreditsPropertyInfo+data AboutDialogVersionPropertyInfo+data AboutDialogWebsitePropertyInfo+data AboutDialogWebsiteLabelPropertyInfo+data AboutDialogWrapLicensePropertyInfo+data AboutDialogActivateLinkSignalInfo
+ GI/Gtk/Objects/AccelGroup.hs view
@@ -0,0 +1,681 @@++{- |+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.Gtk.Objects.AccelGroup+    ( ++-- * Exported types+    AccelGroup(..)                          ,+    AccelGroupK                             ,+    toAccelGroup                            ,+    noAccelGroup                            ,+++ -- * Methods+-- ** accelGroupActivate+    accelGroupActivate                      ,+++-- ** accelGroupConnect+    accelGroupConnect                       ,+++-- ** accelGroupConnectByPath+    accelGroupConnectByPath                 ,+++-- ** accelGroupDisconnect+    accelGroupDisconnect                    ,+++-- ** accelGroupDisconnectKey+    accelGroupDisconnectKey                 ,+++-- ** accelGroupFind+    accelGroupFind                          ,+++-- ** accelGroupFromAccelClosure+    accelGroupFromAccelClosure              ,+++-- ** accelGroupGetIsLocked+    accelGroupGetIsLocked                   ,+++-- ** accelGroupGetModifierMask+    accelGroupGetModifierMask               ,+++-- ** accelGroupLock+    accelGroupLock                          ,+++-- ** accelGroupNew+    accelGroupNew                           ,+++-- ** accelGroupQuery+    accelGroupQuery                         ,+++-- ** accelGroupUnlock+    accelGroupUnlock                        ,+++++ -- * Properties+-- ** IsLocked+    AccelGroupIsLockedPropertyInfo          ,+    getAccelGroupIsLocked                   ,+++-- ** ModifierMask+    AccelGroupModifierMaskPropertyInfo      ,+    getAccelGroupModifierMask               ,+++++ -- * Signals+-- ** AccelActivate+    AccelGroupAccelActivateCallback         ,+    AccelGroupAccelActivateCallbackC        ,+    AccelGroupAccelActivateSignalInfo       ,+    accelGroupAccelActivateCallbackWrapper  ,+    accelGroupAccelActivateClosure          ,+    afterAccelGroupAccelActivate            ,+    mkAccelGroupAccelActivateCallback       ,+    noAccelGroupAccelActivateCallback       ,+    onAccelGroupAccelActivate               ,+++-- ** AccelChanged+    AccelGroupAccelChangedCallback          ,+    AccelGroupAccelChangedCallbackC         ,+    AccelGroupAccelChangedSignalInfo        ,+    accelGroupAccelChangedCallbackWrapper   ,+    accelGroupAccelChangedClosure           ,+    afterAccelGroupAccelChanged             ,+    mkAccelGroupAccelChangedCallback        ,+    noAccelGroupAccelChangedCallback        ,+    onAccelGroupAccelChanged                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype AccelGroup = AccelGroup (ForeignPtr AccelGroup)+foreign import ccall "gtk_accel_group_get_type"+    c_gtk_accel_group_get_type :: IO GType++type instance ParentTypes AccelGroup = AccelGroupParentTypes+type AccelGroupParentTypes = '[GObject.Object]++instance GObject AccelGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_accel_group_get_type+    ++class GObject o => AccelGroupK o+instance (GObject o, IsDescendantOf AccelGroup o) => AccelGroupK o++toAccelGroup :: AccelGroupK o => o -> IO AccelGroup+toAccelGroup = unsafeCastTo AccelGroup++noAccelGroup :: Maybe AccelGroup+noAccelGroup = Nothing++-- signal AccelGroup::accel-activate+type AccelGroupAccelActivateCallback =+    GObject.Object ->+    Word32 ->+    [Gdk.ModifierType] ->+    IO Bool++noAccelGroupAccelActivateCallback :: Maybe AccelGroupAccelActivateCallback+noAccelGroupAccelActivateCallback = Nothing++type AccelGroupAccelActivateCallbackC =+    Ptr () ->                               -- object+    Ptr GObject.Object ->+    Word32 ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkAccelGroupAccelActivateCallback :: AccelGroupAccelActivateCallbackC -> IO (FunPtr AccelGroupAccelActivateCallbackC)++accelGroupAccelActivateClosure :: AccelGroupAccelActivateCallback -> IO Closure+accelGroupAccelActivateClosure cb = newCClosure =<< mkAccelGroupAccelActivateCallback wrapped+    where wrapped = accelGroupAccelActivateCallbackWrapper cb++accelGroupAccelActivateCallbackWrapper ::+    AccelGroupAccelActivateCallback ->+    Ptr () ->+    Ptr GObject.Object ->+    Word32 ->+    CUInt ->+    Ptr () ->+    IO CInt+accelGroupAccelActivateCallbackWrapper _cb _ acceleratable keyval modifier _ = do+    acceleratable' <- (newObject GObject.Object) acceleratable+    let modifier' = wordToGFlags modifier+    result <- _cb  acceleratable' keyval modifier'+    let result' = (fromIntegral . fromEnum) result+    return result'++onAccelGroupAccelActivate :: (GObject a, MonadIO m) => a -> AccelGroupAccelActivateCallback -> m SignalHandlerId+onAccelGroupAccelActivate obj cb = liftIO $ connectAccelGroupAccelActivate obj cb SignalConnectBefore+afterAccelGroupAccelActivate :: (GObject a, MonadIO m) => a -> AccelGroupAccelActivateCallback -> m SignalHandlerId+afterAccelGroupAccelActivate obj cb = connectAccelGroupAccelActivate obj cb SignalConnectAfter++connectAccelGroupAccelActivate :: (GObject a, MonadIO m) =>+                                  a -> AccelGroupAccelActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectAccelGroupAccelActivate obj cb after = liftIO $ do+    cb' <- mkAccelGroupAccelActivateCallback (accelGroupAccelActivateCallbackWrapper cb)+    connectSignalFunPtr obj "accel-activate" cb' after++-- signal AccelGroup::accel-changed+type AccelGroupAccelChangedCallback =+    Word32 ->+    [Gdk.ModifierType] ->+    Closure ->+    IO ()++noAccelGroupAccelChangedCallback :: Maybe AccelGroupAccelChangedCallback+noAccelGroupAccelChangedCallback = Nothing++type AccelGroupAccelChangedCallbackC =+    Ptr () ->                               -- object+    Word32 ->+    CUInt ->+    Ptr Closure ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAccelGroupAccelChangedCallback :: AccelGroupAccelChangedCallbackC -> IO (FunPtr AccelGroupAccelChangedCallbackC)++accelGroupAccelChangedClosure :: AccelGroupAccelChangedCallback -> IO Closure+accelGroupAccelChangedClosure cb = newCClosure =<< mkAccelGroupAccelChangedCallback wrapped+    where wrapped = accelGroupAccelChangedCallbackWrapper cb++accelGroupAccelChangedCallbackWrapper ::+    AccelGroupAccelChangedCallback ->+    Ptr () ->+    Word32 ->+    CUInt ->+    Ptr Closure ->+    Ptr () ->+    IO ()+accelGroupAccelChangedCallbackWrapper _cb _ keyval modifier accel_closure _ = do+    let modifier' = wordToGFlags modifier+    accel_closure' <- (newBoxed Closure) accel_closure+    _cb  keyval modifier' accel_closure'++onAccelGroupAccelChanged :: (GObject a, MonadIO m) => a -> AccelGroupAccelChangedCallback -> m SignalHandlerId+onAccelGroupAccelChanged obj cb = liftIO $ connectAccelGroupAccelChanged obj cb SignalConnectBefore+afterAccelGroupAccelChanged :: (GObject a, MonadIO m) => a -> AccelGroupAccelChangedCallback -> m SignalHandlerId+afterAccelGroupAccelChanged obj cb = connectAccelGroupAccelChanged obj cb SignalConnectAfter++connectAccelGroupAccelChanged :: (GObject a, MonadIO m) =>+                                 a -> AccelGroupAccelChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectAccelGroupAccelChanged obj cb after = liftIO $ do+    cb' <- mkAccelGroupAccelChangedCallback (accelGroupAccelChangedCallbackWrapper cb)+    connectSignalFunPtr obj "accel-changed" cb' after++-- VVV Prop "is-locked"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getAccelGroupIsLocked :: (MonadIO m, AccelGroupK o) => o -> m Bool+getAccelGroupIsLocked obj = liftIO $ getObjectPropertyBool obj "is-locked"++data AccelGroupIsLockedPropertyInfo+instance AttrInfo AccelGroupIsLockedPropertyInfo where+    type AttrAllowedOps AccelGroupIsLockedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint AccelGroupIsLockedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint AccelGroupIsLockedPropertyInfo = AccelGroupK+    type AttrGetType AccelGroupIsLockedPropertyInfo = Bool+    type AttrLabel AccelGroupIsLockedPropertyInfo = "AccelGroup::is-locked"+    attrGet _ = getAccelGroupIsLocked+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "modifier-mask"+   -- Type: TInterface "Gdk" "ModifierType"+   -- Flags: [PropertyReadable]++getAccelGroupModifierMask :: (MonadIO m, AccelGroupK o) => o -> m [Gdk.ModifierType]+getAccelGroupModifierMask obj = liftIO $ getObjectPropertyFlags obj "modifier-mask"++data AccelGroupModifierMaskPropertyInfo+instance AttrInfo AccelGroupModifierMaskPropertyInfo where+    type AttrAllowedOps AccelGroupModifierMaskPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint AccelGroupModifierMaskPropertyInfo = (~) ()+    type AttrBaseTypeConstraint AccelGroupModifierMaskPropertyInfo = AccelGroupK+    type AttrGetType AccelGroupModifierMaskPropertyInfo = [Gdk.ModifierType]+    type AttrLabel AccelGroupModifierMaskPropertyInfo = "AccelGroup::modifier-mask"+    attrGet _ = getAccelGroupModifierMask+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList AccelGroup = AccelGroupAttributeList+type AccelGroupAttributeList = ('[ '("is-locked", AccelGroupIsLockedPropertyInfo), '("modifier-mask", AccelGroupModifierMaskPropertyInfo)] :: [(Symbol, *)])++data AccelGroupAccelActivateSignalInfo+instance SignalInfo AccelGroupAccelActivateSignalInfo where+    type HaskellCallbackType AccelGroupAccelActivateSignalInfo = AccelGroupAccelActivateCallback+    connectSignal _ = connectAccelGroupAccelActivate++data AccelGroupAccelChangedSignalInfo+instance SignalInfo AccelGroupAccelChangedSignalInfo where+    type HaskellCallbackType AccelGroupAccelChangedSignalInfo = AccelGroupAccelChangedCallback+    connectSignal _ = connectAccelGroupAccelChanged++type instance SignalList AccelGroup = AccelGroupSignalList+type AccelGroupSignalList = ('[ '("accel-activate", AccelGroupAccelActivateSignalInfo), '("accel-changed", AccelGroupAccelChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AccelGroup::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "AccelGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_new" gtk_accel_group_new :: +    IO (Ptr AccelGroup)+++accelGroupNew ::+    (MonadIO m) =>+    m AccelGroup+accelGroupNew  = liftIO $ do+    result <- gtk_accel_group_new+    checkUnexpectedReturnNULL "gtk_accel_group_new" result+    result' <- (wrapObject AccelGroup) result+    return result'++-- method AccelGroup::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "acceleratable", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "acceleratable", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_activate" gtk_accel_group_activate :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    Word32 ->                               -- accel_quark : TBasicType TUInt32+    Ptr GObject.Object ->                   -- acceleratable : TInterface "GObject" "Object"+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    IO CInt+++accelGroupActivate ::+    (MonadIO m, AccelGroupK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    Word32 ->                               -- accel_quark+    b ->                                    -- acceleratable+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    m Bool+accelGroupActivate _obj accel_quark acceleratable accel_key accel_mods = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let acceleratable' = unsafeManagedPtrCastPtr acceleratable+    let accel_mods' = gflagsToWord accel_mods+    result <- gtk_accel_group_activate _obj' accel_quark acceleratable' accel_key accel_mods'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr acceleratable+    return result'++-- method AccelGroup::connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_flags", argType = TInterface "Gtk" "AccelFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_flags", argType = TInterface "Gtk" "AccelFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_connect" gtk_accel_group_connect :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    CUInt ->                                -- accel_flags : TInterface "Gtk" "AccelFlags"+    Ptr Closure ->                          -- closure : TInterface "GObject" "Closure"+    IO ()+++accelGroupConnect ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    [AccelFlags] ->                         -- accel_flags+    Closure ->                              -- closure+    m ()+accelGroupConnect _obj accel_key accel_mods accel_flags closure = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_mods' = gflagsToWord accel_mods+    let accel_flags' = gflagsToWord accel_flags+    let closure' = unsafeManagedPtrGetPtr closure+    gtk_accel_group_connect _obj' accel_key accel_mods' accel_flags' closure'+    touchManagedPtr _obj+    touchManagedPtr closure+    return ()++-- method AccelGroup::connect_by_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_connect_by_path" gtk_accel_group_connect_by_path :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    CString ->                              -- accel_path : TBasicType TUTF8+    Ptr Closure ->                          -- closure : TInterface "GObject" "Closure"+    IO ()+++accelGroupConnectByPath ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- accel_path+    Closure ->                              -- closure+    m ()+accelGroupConnectByPath _obj accel_path closure = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    accel_path' <- textToCString accel_path+    let closure' = unsafeManagedPtrGetPtr closure+    gtk_accel_group_connect_by_path _obj' accel_path' closure'+    touchManagedPtr _obj+    touchManagedPtr closure+    freeMem accel_path'+    return ()++-- method AccelGroup::disconnect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_disconnect" gtk_accel_group_disconnect :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    Ptr Closure ->                          -- closure : TInterface "GObject" "Closure"+    IO CInt+++accelGroupDisconnect ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    Maybe (Closure) ->                      -- closure+    m Bool+accelGroupDisconnect _obj closure = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeClosure <- case closure of+        Nothing -> return nullPtr+        Just jClosure -> do+            let jClosure' = unsafeManagedPtrGetPtr jClosure+            return jClosure'+    result <- gtk_accel_group_disconnect _obj' maybeClosure+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust closure touchManagedPtr+    return result'++-- method AccelGroup::disconnect_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_disconnect_key" gtk_accel_group_disconnect_key :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    IO CInt+++accelGroupDisconnectKey ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    m Bool+accelGroupDisconnectKey _obj accel_key accel_mods = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_mods' = gflagsToWord accel_mods+    result <- gtk_accel_group_disconnect_key _obj' accel_key accel_mods'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AccelGroup::find+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "find_func", argType = TInterface "Gtk" "AccelGroupFindFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, 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 "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "find_func", argType = TInterface "Gtk" "AccelGroupFindFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AccelKey"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_find" gtk_accel_group_find :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    FunPtr AccelGroupFindFuncC ->           -- find_func : TInterface "Gtk" "AccelGroupFindFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    IO (Ptr AccelKey)+++accelGroupFind ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    AccelGroupFindFunc ->                   -- find_func+    m AccelKey+accelGroupFind _obj find_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    find_func' <- mkAccelGroupFindFunc (accelGroupFindFuncWrapper Nothing find_func)+    let data_ = nullPtr+    result <- gtk_accel_group_find _obj' find_func' data_+    checkUnexpectedReturnNULL "gtk_accel_group_find" result+    result' <- (newPtr 12 AccelKey) result+    safeFreeFunPtr $ castFunPtrToPtr find_func'+    touchManagedPtr _obj+    return result'++-- method AccelGroup::get_is_locked+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_get_is_locked" gtk_accel_group_get_is_locked :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    IO CInt+++accelGroupGetIsLocked ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    m Bool+accelGroupGetIsLocked _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accel_group_get_is_locked _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AccelGroup::get_modifier_mask+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "ModifierType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_get_modifier_mask" gtk_accel_group_get_modifier_mask :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    IO CUInt+++accelGroupGetModifierMask ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    m [Gdk.ModifierType]+accelGroupGetModifierMask _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accel_group_get_modifier_mask _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method AccelGroup::lock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_lock" gtk_accel_group_lock :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    IO ()+++accelGroupLock ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    m ()+accelGroupLock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_accel_group_lock _obj'+    touchManagedPtr _obj+    return ()++-- method AccelGroup::query+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_entries", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_entries", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 3 (TInterface "Gtk" "AccelGroupEntry")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_query" gtk_accel_group_query :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    Ptr Word32 ->                           -- n_entries : TBasicType TUInt32+    IO (Ptr AccelGroupEntry)+++accelGroupQuery ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    m [AccelGroupEntry]+accelGroupQuery _obj accel_key accel_mods = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_mods' = gflagsToWord accel_mods+    n_entries <- allocMem :: IO (Ptr Word32)+    result <- gtk_accel_group_query _obj' accel_key accel_mods' n_entries+    n_entries' <- peek n_entries+    checkUnexpectedReturnNULL "gtk_accel_group_query" result+    result' <- (unpackBlockArrayWithLength 32 n_entries') result+    result'' <- mapM (newPtr 32 AccelGroupEntry) result'+    touchManagedPtr _obj+    freeMem n_entries+    return result''++-- method AccelGroup::unlock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_unlock" gtk_accel_group_unlock :: +    Ptr AccelGroup ->                       -- _obj : TInterface "Gtk" "AccelGroup"+    IO ()+++accelGroupUnlock ::+    (MonadIO m, AccelGroupK a) =>+    a ->                                    -- _obj+    m ()+accelGroupUnlock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_accel_group_unlock _obj'+    touchManagedPtr _obj+    return ()++-- method AccelGroup::from_accel_closure+-- method type : MemberFunction+-- Args : [Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AccelGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_group_from_accel_closure" gtk_accel_group_from_accel_closure :: +    Ptr Closure ->                          -- closure : TInterface "GObject" "Closure"+    IO (Ptr AccelGroup)+++accelGroupFromAccelClosure ::+    (MonadIO m) =>+    Closure ->                              -- closure+    m AccelGroup+accelGroupFromAccelClosure closure = liftIO $ do+    let closure' = unsafeManagedPtrGetPtr closure+    result <- gtk_accel_group_from_accel_closure closure'+    checkUnexpectedReturnNULL "gtk_accel_group_from_accel_closure" result+    result' <- (newObject AccelGroup) result+    touchManagedPtr closure+    return result'++
+ GI/Gtk/Objects/AccelGroup.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.AccelGroup where++import Prelude ()+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 AccelGroup = AccelGroup (ForeignPtr AccelGroup)+instance GObject AccelGroup where+class GObject o => AccelGroupK o+instance (GObject o, IsDescendantOf AccelGroup o) => AccelGroupK o+data AccelGroupIsLockedPropertyInfo+data AccelGroupModifierMaskPropertyInfo+data AccelGroupAccelActivateSignalInfo+data AccelGroupAccelChangedSignalInfo
+ GI/Gtk/Objects/AccelLabel.hs view
@@ -0,0 +1,385 @@++{- |+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.Gtk.Objects.AccelLabel+    ( ++-- * Exported types+    AccelLabel(..)                          ,+    AccelLabelK                             ,+    toAccelLabel                            ,+    noAccelLabel                            ,+++ -- * Methods+-- ** accelLabelGetAccel+    accelLabelGetAccel                      ,+++-- ** accelLabelGetAccelWidget+    accelLabelGetAccelWidget                ,+++-- ** accelLabelGetAccelWidth+    accelLabelGetAccelWidth                 ,+++-- ** accelLabelNew+    accelLabelNew                           ,+++-- ** accelLabelRefetch+    accelLabelRefetch                       ,+++-- ** accelLabelSetAccel+    accelLabelSetAccel                      ,+++-- ** accelLabelSetAccelClosure+    accelLabelSetAccelClosure               ,+++-- ** accelLabelSetAccelWidget+    accelLabelSetAccelWidget                ,+++++ -- * Properties+-- ** AccelClosure+    AccelLabelAccelClosurePropertyInfo      ,+    constructAccelLabelAccelClosure         ,+    getAccelLabelAccelClosure               ,+    setAccelLabelAccelClosure               ,+++-- ** AccelWidget+    AccelLabelAccelWidgetPropertyInfo       ,+    constructAccelLabelAccelWidget          ,+    getAccelLabelAccelWidget                ,+    setAccelLabelAccelWidget                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype AccelLabel = AccelLabel (ForeignPtr AccelLabel)+foreign import ccall "gtk_accel_label_get_type"+    c_gtk_accel_label_get_type :: IO GType++type instance ParentTypes AccelLabel = AccelLabelParentTypes+type AccelLabelParentTypes = '[Label, Misc, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject AccelLabel where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_accel_label_get_type+    ++class GObject o => AccelLabelK o+instance (GObject o, IsDescendantOf AccelLabel o) => AccelLabelK o++toAccelLabel :: AccelLabelK o => o -> IO AccelLabel+toAccelLabel = unsafeCastTo AccelLabel++noAccelLabel :: Maybe AccelLabel+noAccelLabel = Nothing++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_halign() instead. If you are using\n  #GtkLabel, use #GtkLabel:xalign instead."})}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_valign() instead. If you are using\n  #GtkLabel, use #GtkLabel:yalign instead."})}+-- VVV Prop "accel-closure"+   -- Type: TInterface "GObject" "Closure"+   -- Flags: [PropertyReadable,PropertyWritable]++getAccelLabelAccelClosure :: (MonadIO m, AccelLabelK o) => o -> m Closure+getAccelLabelAccelClosure obj = liftIO $ getObjectPropertyBoxed obj "accel-closure" Closure++setAccelLabelAccelClosure :: (MonadIO m, AccelLabelK o) => o -> Closure -> m ()+setAccelLabelAccelClosure obj val = liftIO $ setObjectPropertyBoxed obj "accel-closure" val++constructAccelLabelAccelClosure :: Closure -> IO ([Char], GValue)+constructAccelLabelAccelClosure val = constructObjectPropertyBoxed "accel-closure" val++data AccelLabelAccelClosurePropertyInfo+instance AttrInfo AccelLabelAccelClosurePropertyInfo where+    type AttrAllowedOps AccelLabelAccelClosurePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AccelLabelAccelClosurePropertyInfo = (~) Closure+    type AttrBaseTypeConstraint AccelLabelAccelClosurePropertyInfo = AccelLabelK+    type AttrGetType AccelLabelAccelClosurePropertyInfo = Closure+    type AttrLabel AccelLabelAccelClosurePropertyInfo = "AccelLabel::accel-closure"+    attrGet _ = getAccelLabelAccelClosure+    attrSet _ = setAccelLabelAccelClosure+    attrConstruct _ = constructAccelLabelAccelClosure++-- VVV Prop "accel-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getAccelLabelAccelWidget :: (MonadIO m, AccelLabelK o) => o -> m Widget+getAccelLabelAccelWidget obj = liftIO $ getObjectPropertyObject obj "accel-widget" Widget++setAccelLabelAccelWidget :: (MonadIO m, AccelLabelK o, WidgetK a) => o -> a -> m ()+setAccelLabelAccelWidget obj val = liftIO $ setObjectPropertyObject obj "accel-widget" val++constructAccelLabelAccelWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructAccelLabelAccelWidget val = constructObjectPropertyObject "accel-widget" val++data AccelLabelAccelWidgetPropertyInfo+instance AttrInfo AccelLabelAccelWidgetPropertyInfo where+    type AttrAllowedOps AccelLabelAccelWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AccelLabelAccelWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint AccelLabelAccelWidgetPropertyInfo = AccelLabelK+    type AttrGetType AccelLabelAccelWidgetPropertyInfo = Widget+    type AttrLabel AccelLabelAccelWidgetPropertyInfo = "AccelLabel::accel-widget"+    attrGet _ = getAccelLabelAccelWidget+    attrSet _ = setAccelLabelAccelWidget+    attrConstruct _ = constructAccelLabelAccelWidget++type instance AttributeList AccelLabel = AccelLabelAttributeList+type AccelLabelAttributeList = ('[ '("accel-closure", AccelLabelAccelClosurePropertyInfo), '("accel-widget", AccelLabelAccelWidgetPropertyInfo), '("angle", LabelAnglePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("attributes", LabelAttributesPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("cursor-position", LabelCursorPositionPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("ellipsize", LabelEllipsizePropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("justify", LabelJustifyPropertyInfo), '("label", LabelLabelPropertyInfo), '("lines", LabelLinesPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-width-chars", LabelMaxWidthCharsPropertyInfo), '("mnemonic-keyval", LabelMnemonicKeyvalPropertyInfo), '("mnemonic-widget", LabelMnemonicWidgetPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pattern", LabelPatternPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selectable", LabelSelectablePropertyInfo), '("selection-bound", LabelSelectionBoundPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("single-line-mode", LabelSingleLineModePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("track-visited-links", LabelTrackVisitedLinksPropertyInfo), '("use-markup", LabelUseMarkupPropertyInfo), '("use-underline", LabelUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-chars", LabelWidthCharsPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("wrap", LabelWrapPropertyInfo), '("wrap-mode", LabelWrapModePropertyInfo), '("xpad", MiscXpadPropertyInfo), '("ypad", MiscYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList AccelLabel = AccelLabelSignalList+type AccelLabelSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-current-link", LabelActivateCurrentLinkSignalInfo), '("activate-link", LabelActivateLinkSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("copy-clipboard", LabelCopyClipboardSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", LabelMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("populate-popup", LabelPopulatePopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AccelLabel::new+-- 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 "Gtk" "AccelLabel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_new" gtk_accel_label_new :: +    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr AccelLabel)+++accelLabelNew ::+    (MonadIO m) =>+    T.Text ->                               -- string+    m AccelLabel+accelLabelNew string = liftIO $ do+    string' <- textToCString string+    result <- gtk_accel_label_new string'+    checkUnexpectedReturnNULL "gtk_accel_label_new" result+    result' <- (newObject AccelLabel) result+    freeMem string'+    return result'++-- method AccelLabel::get_accel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_get_accel" gtk_accel_label_get_accel :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    Ptr Word32 ->                           -- accelerator_key : TBasicType TUInt32+    Ptr CUInt ->                            -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO ()+++accelLabelGetAccel ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    m (Word32,[Gdk.ModifierType])+accelLabelGetAccel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    accelerator_key <- allocMem :: IO (Ptr Word32)+    accelerator_mods <- allocMem :: IO (Ptr CUInt)+    gtk_accel_label_get_accel _obj' accelerator_key accelerator_mods+    accelerator_key' <- peek accelerator_key+    accelerator_mods' <- peek accelerator_mods+    let accelerator_mods'' = wordToGFlags accelerator_mods'+    touchManagedPtr _obj+    freeMem accelerator_key+    freeMem accelerator_mods+    return (accelerator_key', accelerator_mods'')++-- method AccelLabel::get_accel_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_get_accel_widget" gtk_accel_label_get_accel_widget :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    IO (Ptr Widget)+++accelLabelGetAccelWidget ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    m Widget+accelLabelGetAccelWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accel_label_get_accel_widget _obj'+    checkUnexpectedReturnNULL "gtk_accel_label_get_accel_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method AccelLabel::get_accel_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_get_accel_width" gtk_accel_label_get_accel_width :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    IO Word32+++accelLabelGetAccelWidth ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    m Word32+accelLabelGetAccelWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accel_label_get_accel_width _obj'+    touchManagedPtr _obj+    return result++-- method AccelLabel::refetch+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_refetch" gtk_accel_label_refetch :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    IO CInt+++accelLabelRefetch ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    m Bool+accelLabelRefetch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accel_label_refetch _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AccelLabel::set_accel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_set_accel" gtk_accel_label_set_accel :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    Word32 ->                               -- accelerator_key : TBasicType TUInt32+    CUInt ->                                -- accelerator_mods : TInterface "Gdk" "ModifierType"+    IO ()+++accelLabelSetAccel ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- accelerator_key+    [Gdk.ModifierType] ->                   -- accelerator_mods+    m ()+accelLabelSetAccel _obj accelerator_key accelerator_mods = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accelerator_mods' = gflagsToWord accelerator_mods+    gtk_accel_label_set_accel _obj' accelerator_key accelerator_mods'+    touchManagedPtr _obj+    return ()++-- method AccelLabel::set_accel_closure+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_closure", argType = TInterface "GObject" "Closure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_set_accel_closure" gtk_accel_label_set_accel_closure :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    Ptr Closure ->                          -- accel_closure : TInterface "GObject" "Closure"+    IO ()+++accelLabelSetAccelClosure ::+    (MonadIO m, AccelLabelK a) =>+    a ->                                    -- _obj+    Closure ->                              -- accel_closure+    m ()+accelLabelSetAccelClosure _obj accel_closure = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_closure' = unsafeManagedPtrGetPtr accel_closure+    gtk_accel_label_set_accel_closure _obj' accel_closure'+    touchManagedPtr _obj+    touchManagedPtr accel_closure+    return ()++-- method AccelLabel::set_accel_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AccelLabel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_label_set_accel_widget" gtk_accel_label_set_accel_widget :: +    Ptr AccelLabel ->                       -- _obj : TInterface "Gtk" "AccelLabel"+    Ptr Widget ->                           -- accel_widget : TInterface "Gtk" "Widget"+    IO ()+++accelLabelSetAccelWidget ::+    (MonadIO m, AccelLabelK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- accel_widget+    m ()+accelLabelSetAccelWidget _obj accel_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_widget' = unsafeManagedPtrCastPtr accel_widget+    gtk_accel_label_set_accel_widget _obj' accel_widget'+    touchManagedPtr _obj+    touchManagedPtr accel_widget+    return ()++
+ GI/Gtk/Objects/AccelLabel.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.AccelLabel where++import Prelude ()+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 AccelLabel = AccelLabel (ForeignPtr AccelLabel)+instance GObject AccelLabel where+class GObject o => AccelLabelK o+instance (GObject o, IsDescendantOf AccelLabel o) => AccelLabelK o+data AccelLabelAccelClosurePropertyInfo+data AccelLabelAccelWidgetPropertyInfo
+ GI/Gtk/Objects/AccelMap.hs view
@@ -0,0 +1,544 @@++{- |+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.Gtk.Objects.AccelMap+    ( ++-- * Exported types+    AccelMap(..)                            ,+    AccelMapK                               ,+    toAccelMap                              ,+    noAccelMap                              ,+++ -- * Methods+-- ** accelMapAddEntry+    accelMapAddEntry                        ,+++-- ** accelMapAddFilter+    accelMapAddFilter                       ,+++-- ** accelMapChangeEntry+    accelMapChangeEntry                     ,+++-- ** accelMapForeach+    accelMapForeach                         ,+++-- ** accelMapForeachUnfiltered+    accelMapForeachUnfiltered               ,+++-- ** accelMapGet+    accelMapGet                             ,+++-- ** accelMapLoad+    accelMapLoad                            ,+++-- ** accelMapLoadFd+    accelMapLoadFd                          ,+++-- ** accelMapLoadScanner+    accelMapLoadScanner                     ,+++-- ** accelMapLockPath+    accelMapLockPath                        ,+++-- ** accelMapLookupEntry+    accelMapLookupEntry                     ,+++-- ** accelMapSave+    accelMapSave                            ,+++-- ** accelMapSaveFd+    accelMapSaveFd                          ,+++-- ** accelMapUnlockPath+    accelMapUnlockPath                      ,+++++ -- * Signals+-- ** Changed+    AccelMapChangedCallback                 ,+    AccelMapChangedCallbackC                ,+    AccelMapChangedSignalInfo               ,+    accelMapChangedCallbackWrapper          ,+    accelMapChangedClosure                  ,+    afterAccelMapChanged                    ,+    mkAccelMapChangedCallback               ,+    noAccelMapChangedCallback               ,+    onAccelMapChanged                       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype AccelMap = AccelMap (ForeignPtr AccelMap)+foreign import ccall "gtk_accel_map_get_type"+    c_gtk_accel_map_get_type :: IO GType++type instance ParentTypes AccelMap = AccelMapParentTypes+type AccelMapParentTypes = '[GObject.Object]++instance GObject AccelMap where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_accel_map_get_type+    ++class GObject o => AccelMapK o+instance (GObject o, IsDescendantOf AccelMap o) => AccelMapK o++toAccelMap :: AccelMapK o => o -> IO AccelMap+toAccelMap = unsafeCastTo AccelMap++noAccelMap :: Maybe AccelMap+noAccelMap = Nothing++-- signal AccelMap::changed+type AccelMapChangedCallback =+    T.Text ->+    Word32 ->+    [Gdk.ModifierType] ->+    IO ()++noAccelMapChangedCallback :: Maybe AccelMapChangedCallback+noAccelMapChangedCallback = Nothing++type AccelMapChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Word32 ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAccelMapChangedCallback :: AccelMapChangedCallbackC -> IO (FunPtr AccelMapChangedCallbackC)++accelMapChangedClosure :: AccelMapChangedCallback -> IO Closure+accelMapChangedClosure cb = newCClosure =<< mkAccelMapChangedCallback wrapped+    where wrapped = accelMapChangedCallbackWrapper cb++accelMapChangedCallbackWrapper ::+    AccelMapChangedCallback ->+    Ptr () ->+    CString ->+    Word32 ->+    CUInt ->+    Ptr () ->+    IO ()+accelMapChangedCallbackWrapper _cb _ accel_path accel_key accel_mods _ = do+    accel_path' <- cstringToText accel_path+    let accel_mods' = wordToGFlags accel_mods+    _cb  accel_path' accel_key accel_mods'++onAccelMapChanged :: (GObject a, MonadIO m) => a -> AccelMapChangedCallback -> m SignalHandlerId+onAccelMapChanged obj cb = liftIO $ connectAccelMapChanged obj cb SignalConnectBefore+afterAccelMapChanged :: (GObject a, MonadIO m) => a -> AccelMapChangedCallback -> m SignalHandlerId+afterAccelMapChanged obj cb = connectAccelMapChanged obj cb SignalConnectAfter++connectAccelMapChanged :: (GObject a, MonadIO m) =>+                          a -> AccelMapChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectAccelMapChanged obj cb after = liftIO $ do+    cb' <- mkAccelMapChangedCallback (accelMapChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++type instance AttributeList AccelMap = AccelMapAttributeList+type AccelMapAttributeList = ('[ ] :: [(Symbol, *)])++data AccelMapChangedSignalInfo+instance SignalInfo AccelMapChangedSignalInfo where+    type HaskellCallbackType AccelMapChangedSignalInfo = AccelMapChangedCallback+    connectSignal _ = connectAccelMapChanged++type instance SignalList AccelMap = AccelMapSignalList+type AccelMapSignalList = ('[ '("changed", AccelMapChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AccelMap::add_entry+-- method type : MemberFunction+-- Args : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_add_entry" gtk_accel_map_add_entry :: +    CString ->                              -- accel_path : TBasicType TUTF8+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    IO ()+++accelMapAddEntry ::+    (MonadIO m) =>+    T.Text ->                               -- accel_path+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    m ()+accelMapAddEntry accel_path accel_key accel_mods = liftIO $ do+    accel_path' <- textToCString accel_path+    let accel_mods' = gflagsToWord accel_mods+    gtk_accel_map_add_entry accel_path' accel_key accel_mods'+    freeMem accel_path'+    return ()++-- method AccelMap::add_filter+-- method type : MemberFunction+-- Args : [Arg {argName = "filter_pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "filter_pattern", 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 "gtk_accel_map_add_filter" gtk_accel_map_add_filter :: +    CString ->                              -- filter_pattern : TBasicType TUTF8+    IO ()+++accelMapAddFilter ::+    (MonadIO m) =>+    T.Text ->                               -- filter_pattern+    m ()+accelMapAddFilter filter_pattern = liftIO $ do+    filter_pattern' <- textToCString filter_pattern+    gtk_accel_map_add_filter filter_pattern'+    freeMem filter_pattern'+    return ()++-- method AccelMap::change_entry+-- method type : MemberFunction+-- Args : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "replace", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_key", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_mods", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "replace", 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 "gtk_accel_map_change_entry" gtk_accel_map_change_entry :: +    CString ->                              -- accel_path : TBasicType TUTF8+    Word32 ->                               -- accel_key : TBasicType TUInt32+    CUInt ->                                -- accel_mods : TInterface "Gdk" "ModifierType"+    CInt ->                                 -- replace : TBasicType TBoolean+    IO CInt+++accelMapChangeEntry ::+    (MonadIO m) =>+    T.Text ->                               -- accel_path+    Word32 ->                               -- accel_key+    [Gdk.ModifierType] ->                   -- accel_mods+    Bool ->                                 -- replace+    m Bool+accelMapChangeEntry accel_path accel_key accel_mods replace = liftIO $ do+    accel_path' <- textToCString accel_path+    let accel_mods' = gflagsToWord accel_mods+    let replace' = (fromIntegral . fromEnum) replace+    result <- gtk_accel_map_change_entry accel_path' accel_key accel_mods' replace'+    let result' = (/= 0) result+    freeMem accel_path'+    return result'++-- method AccelMap::foreach+-- method type : MemberFunction+-- Args : [Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreach_func", argType = TInterface "Gtk" "AccelMapForeach", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreach_func", argType = TInterface "Gtk" "AccelMapForeach", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_foreach" gtk_accel_map_foreach :: +    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr AccelMapForeachC ->              -- foreach_func : TInterface "Gtk" "AccelMapForeach"+    IO ()+++accelMapForeach ::+    (MonadIO m) =>+    Maybe (Ptr ()) ->                       -- data+    AccelMapForeach ->                      -- foreach_func+    m ()+accelMapForeach data_ foreach_func = liftIO $ do+    maybeData_ <- case data_ of+        Nothing -> return nullPtr+        Just jData_ -> do+            return jData_+    foreach_func' <- mkAccelMapForeach (accelMapForeachWrapper Nothing foreach_func)+    gtk_accel_map_foreach maybeData_ foreach_func'+    safeFreeFunPtr $ castFunPtrToPtr foreach_func'+    return ()++-- method AccelMap::foreach_unfiltered+-- method type : MemberFunction+-- Args : [Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreach_func", argType = TInterface "Gtk" "AccelMapForeach", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "foreach_func", argType = TInterface "Gtk" "AccelMapForeach", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_foreach_unfiltered" gtk_accel_map_foreach_unfiltered :: +    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr AccelMapForeachC ->              -- foreach_func : TInterface "Gtk" "AccelMapForeach"+    IO ()+++accelMapForeachUnfiltered ::+    (MonadIO m) =>+    Ptr () ->                               -- data+    AccelMapForeach ->                      -- foreach_func+    m ()+accelMapForeachUnfiltered data_ foreach_func = liftIO $ do+    foreach_func' <- mkAccelMapForeach (accelMapForeachWrapper Nothing foreach_func)+    gtk_accel_map_foreach_unfiltered data_ foreach_func'+    safeFreeFunPtr $ castFunPtrToPtr foreach_func'+    return ()++-- method AccelMap::get+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "AccelMap"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_get" gtk_accel_map_get :: +    IO (Ptr AccelMap)+++accelMapGet ::+    (MonadIO m) =>+    m AccelMap+accelMapGet  = liftIO $ do+    result <- gtk_accel_map_get+    checkUnexpectedReturnNULL "gtk_accel_map_get" result+    result' <- (newObject AccelMap) result+    return result'++-- method AccelMap::load+-- method type : MemberFunction+-- Args : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_load" gtk_accel_map_load :: +    CString ->                              -- file_name : TBasicType TFileName+    IO ()+++accelMapLoad ::+    (MonadIO m) =>+    [Char] ->                               -- file_name+    m ()+accelMapLoad file_name = liftIO $ do+    file_name' <- stringToCString file_name+    gtk_accel_map_load file_name'+    freeMem file_name'+    return ()++-- method AccelMap::load_fd+-- method type : MemberFunction+-- 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_load_fd" gtk_accel_map_load_fd :: +    Int32 ->                                -- fd : TBasicType TInt32+    IO ()+++accelMapLoadFd ::+    (MonadIO m) =>+    Int32 ->                                -- fd+    m ()+accelMapLoadFd fd = liftIO $ do+    gtk_accel_map_load_fd fd+    return ()++-- method AccelMap::load_scanner+-- method type : MemberFunction+-- Args : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "scanner", argType = TInterface "GLib" "Scanner", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_load_scanner" gtk_accel_map_load_scanner :: +    Ptr GLib.Scanner ->                     -- scanner : TInterface "GLib" "Scanner"+    IO ()+++accelMapLoadScanner ::+    (MonadIO m) =>+    GLib.Scanner ->                         -- scanner+    m ()+accelMapLoadScanner scanner = liftIO $ do+    let scanner' = unsafeManagedPtrGetPtr scanner+    gtk_accel_map_load_scanner scanner'+    touchManagedPtr scanner+    return ()++-- method AccelMap::lock_path+-- method type : MemberFunction+-- Args : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accel_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 "gtk_accel_map_lock_path" gtk_accel_map_lock_path :: +    CString ->                              -- accel_path : TBasicType TUTF8+    IO ()+++accelMapLockPath ::+    (MonadIO m) =>+    T.Text ->                               -- accel_path+    m ()+accelMapLockPath accel_path = liftIO $ do+    accel_path' <- textToCString accel_path+    gtk_accel_map_lock_path accel_path'+    freeMem accel_path'+    return ()++-- method AccelMap::lookup_entry+-- method type : MemberFunction+-- Args : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key", argType = TInterface "Gtk" "AccelKey", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accel_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 "gtk_accel_map_lookup_entry" gtk_accel_map_lookup_entry :: +    CString ->                              -- accel_path : TBasicType TUTF8+    Ptr AccelKey ->                         -- key : TInterface "Gtk" "AccelKey"+    IO CInt+++accelMapLookupEntry ::+    (MonadIO m) =>+    T.Text ->                               -- accel_path+    m (Bool,AccelKey)+accelMapLookupEntry accel_path = liftIO $ do+    accel_path' <- textToCString accel_path+    key <- callocBytes 12 :: IO (Ptr AccelKey)+    result <- gtk_accel_map_lookup_entry accel_path' key+    let result' = (/= 0) result+    key' <- (wrapPtr AccelKey) key+    freeMem accel_path'+    return (result', key')++-- method AccelMap::save+-- method type : MemberFunction+-- Args : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_save" gtk_accel_map_save :: +    CString ->                              -- file_name : TBasicType TFileName+    IO ()+++accelMapSave ::+    (MonadIO m) =>+    [Char] ->                               -- file_name+    m ()+accelMapSave file_name = liftIO $ do+    file_name' <- stringToCString file_name+    gtk_accel_map_save file_name'+    freeMem file_name'+    return ()++-- method AccelMap::save_fd+-- method type : MemberFunction+-- 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accel_map_save_fd" gtk_accel_map_save_fd :: +    Int32 ->                                -- fd : TBasicType TInt32+    IO ()+++accelMapSaveFd ::+    (MonadIO m) =>+    Int32 ->                                -- fd+    m ()+accelMapSaveFd fd = liftIO $ do+    gtk_accel_map_save_fd fd+    return ()++-- method AccelMap::unlock_path+-- method type : MemberFunction+-- Args : [Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "accel_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 "gtk_accel_map_unlock_path" gtk_accel_map_unlock_path :: +    CString ->                              -- accel_path : TBasicType TUTF8+    IO ()+++accelMapUnlockPath ::+    (MonadIO m) =>+    T.Text ->                               -- accel_path+    m ()+accelMapUnlockPath accel_path = liftIO $ do+    accel_path' <- textToCString accel_path+    gtk_accel_map_unlock_path accel_path'+    freeMem accel_path'+    return ()++
+ GI/Gtk/Objects/AccelMap.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.AccelMap where++import Prelude ()+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 AccelMap = AccelMap (ForeignPtr AccelMap)+instance GObject AccelMap where+class GObject o => AccelMapK o+instance (GObject o, IsDescendantOf AccelMap o) => AccelMapK o+data AccelMapChangedSignalInfo
+ GI/Gtk/Objects/Accessible.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.Gtk.Objects.Accessible+    ( ++-- * Exported types+    Accessible(..)                          ,+    AccessibleK                             ,+    toAccessible                            ,+    noAccessible                            ,+++ -- * Methods+-- ** accessibleConnectWidgetDestroyed+    accessibleConnectWidgetDestroyed        ,+++-- ** accessibleGetWidget+    accessibleGetWidget                     ,+++-- ** accessibleSetWidget+    accessibleSetWidget                     ,+++++ -- * Properties+-- ** Widget+    AccessibleWidgetPropertyInfo            ,+    constructAccessibleWidget               ,+    getAccessibleWidget                     ,+    setAccessibleWidget                     ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Accessible = Accessible (ForeignPtr Accessible)+foreign import ccall "gtk_accessible_get_type"+    c_gtk_accessible_get_type :: IO GType++type instance ParentTypes Accessible = AccessibleParentTypes+type AccessibleParentTypes = '[Atk.Object, GObject.Object]++instance GObject Accessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_accessible_get_type+    ++class GObject o => AccessibleK o+instance (GObject o, IsDescendantOf Accessible o) => AccessibleK o++toAccessible :: AccessibleK o => o -> IO Accessible+toAccessible = unsafeCastTo Accessible++noAccessible :: Maybe Accessible+noAccessible = Nothing++-- VVV Prop "widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getAccessibleWidget :: (MonadIO m, AccessibleK o) => o -> m Widget+getAccessibleWidget obj = liftIO $ getObjectPropertyObject obj "widget" Widget++setAccessibleWidget :: (MonadIO m, AccessibleK o, WidgetK a) => o -> a -> m ()+setAccessibleWidget obj val = liftIO $ setObjectPropertyObject obj "widget" val++constructAccessibleWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructAccessibleWidget val = constructObjectPropertyObject "widget" val++data AccessibleWidgetPropertyInfo+instance AttrInfo AccessibleWidgetPropertyInfo where+    type AttrAllowedOps AccessibleWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AccessibleWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint AccessibleWidgetPropertyInfo = AccessibleK+    type AttrGetType AccessibleWidgetPropertyInfo = Widget+    type AttrLabel AccessibleWidgetPropertyInfo = "Accessible::widget"+    attrGet _ = getAccessibleWidget+    attrSet _ = setAccessibleWidget+    attrConstruct _ = constructAccessibleWidget++type instance AttributeList Accessible = AccessibleAttributeList+type AccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Accessible = AccessibleSignalList+type AccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Accessible::connect_widget_destroyed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accessible_connect_widget_destroyed" gtk_accessible_connect_widget_destroyed :: +    Ptr Accessible ->                       -- _obj : TInterface "Gtk" "Accessible"+    IO ()++{-# DEPRECATED accessibleConnectWidgetDestroyed ["(Since version 3.4)","Use gtk_accessible_set_widget() and its vfuncs."]#-}+accessibleConnectWidgetDestroyed ::+    (MonadIO m, AccessibleK a) =>+    a ->                                    -- _obj+    m ()+accessibleConnectWidgetDestroyed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_accessible_connect_widget_destroyed _obj'+    touchManagedPtr _obj+    return ()++-- method Accessible::get_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accessible_get_widget" gtk_accessible_get_widget :: +    Ptr Accessible ->                       -- _obj : TInterface "Gtk" "Accessible"+    IO (Ptr Widget)+++accessibleGetWidget ::+    (MonadIO m, AccessibleK a) =>+    a ->                                    -- _obj+    m Widget+accessibleGetWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_accessible_get_widget _obj'+    checkUnexpectedReturnNULL "gtk_accessible_get_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Accessible::set_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Accessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_accessible_set_widget" gtk_accessible_set_widget :: +    Ptr Accessible ->                       -- _obj : TInterface "Gtk" "Accessible"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++accessibleSetWidget ::+    (MonadIO m, AccessibleK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- widget+    m ()+accessibleSetWidget _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    gtk_accessible_set_widget _obj' maybeWidget+    touchManagedPtr _obj+    whenJust widget touchManagedPtr+    return ()++
+ GI/Gtk/Objects/Accessible.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.Accessible where++import Prelude ()+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 Accessible = Accessible (ForeignPtr Accessible)+instance GObject Accessible where+class GObject o => AccessibleK o+instance (GObject o, IsDescendantOf Accessible o) => AccessibleK o+data AccessibleWidgetPropertyInfo
+ GI/Gtk/Objects/Action.hs view
@@ -0,0 +1,1910 @@++{- |+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.Gtk.Objects.Action+    ( ++-- * Exported types+    Action(..)                              ,+    ActionK                                 ,+    toAction                                ,+    noAction                                ,+++ -- * Methods+-- ** actionActivate+    actionActivate                          ,+++-- ** actionBlockActivate+    actionBlockActivate                     ,+++-- ** actionConnectAccelerator+    actionConnectAccelerator                ,+++-- ** actionCreateIcon+    actionCreateIcon                        ,+++-- ** actionCreateMenu+    actionCreateMenu                        ,+++-- ** actionCreateMenuItem+    actionCreateMenuItem                    ,+++-- ** actionCreateToolItem+    actionCreateToolItem                    ,+++-- ** actionDisconnectAccelerator+    actionDisconnectAccelerator             ,+++-- ** actionGetAccelClosure+    actionGetAccelClosure                   ,+++-- ** actionGetAccelPath+    actionGetAccelPath                      ,+++-- ** actionGetAlwaysShowImage+    actionGetAlwaysShowImage                ,+++-- ** actionGetGicon+    actionGetGicon                          ,+++-- ** actionGetIconName+    actionGetIconName                       ,+++-- ** actionGetIsImportant+    actionGetIsImportant                    ,+++-- ** actionGetLabel+    actionGetLabel                          ,+++-- ** actionGetName+    actionGetName                           ,+++-- ** actionGetProxies+    actionGetProxies                        ,+++-- ** actionGetSensitive+    actionGetSensitive                      ,+++-- ** actionGetShortLabel+    actionGetShortLabel                     ,+++-- ** actionGetStockId+    actionGetStockId                        ,+++-- ** actionGetTooltip+    actionGetTooltip                        ,+++-- ** actionGetVisible+    actionGetVisible                        ,+++-- ** actionGetVisibleHorizontal+    actionGetVisibleHorizontal              ,+++-- ** actionGetVisibleVertical+    actionGetVisibleVertical                ,+++-- ** actionIsSensitive+    actionIsSensitive                       ,+++-- ** actionIsVisible+    actionIsVisible                         ,+++-- ** actionNew+    actionNew                               ,+++-- ** actionSetAccelGroup+    actionSetAccelGroup                     ,+++-- ** actionSetAccelPath+    actionSetAccelPath                      ,+++-- ** actionSetAlwaysShowImage+    actionSetAlwaysShowImage                ,+++-- ** actionSetGicon+    actionSetGicon                          ,+++-- ** actionSetIconName+    actionSetIconName                       ,+++-- ** actionSetIsImportant+    actionSetIsImportant                    ,+++-- ** actionSetLabel+    actionSetLabel                          ,+++-- ** actionSetSensitive+    actionSetSensitive                      ,+++-- ** actionSetShortLabel+    actionSetShortLabel                     ,+++-- ** actionSetStockId+    actionSetStockId                        ,+++-- ** actionSetTooltip+    actionSetTooltip                        ,+++-- ** actionSetVisible+    actionSetVisible                        ,+++-- ** actionSetVisibleHorizontal+    actionSetVisibleHorizontal              ,+++-- ** actionSetVisibleVertical+    actionSetVisibleVertical                ,+++-- ** actionUnblockActivate+    actionUnblockActivate                   ,+++++ -- * Properties+-- ** ActionGroup+    ActionActionGroupPropertyInfo           ,+    constructActionActionGroup              ,+    getActionActionGroup                    ,+    setActionActionGroup                    ,+++-- ** AlwaysShowImage+    ActionAlwaysShowImagePropertyInfo       ,+    constructActionAlwaysShowImage          ,+    getActionAlwaysShowImage                ,+    setActionAlwaysShowImage                ,+++-- ** Gicon+    ActionGiconPropertyInfo                 ,+    constructActionGicon                    ,+    getActionGicon                          ,+    setActionGicon                          ,+++-- ** HideIfEmpty+    ActionHideIfEmptyPropertyInfo           ,+    constructActionHideIfEmpty              ,+    getActionHideIfEmpty                    ,+    setActionHideIfEmpty                    ,+++-- ** IconName+    ActionIconNamePropertyInfo              ,+    constructActionIconName                 ,+    getActionIconName                       ,+    setActionIconName                       ,+++-- ** IsImportant+    ActionIsImportantPropertyInfo           ,+    constructActionIsImportant              ,+    getActionIsImportant                    ,+    setActionIsImportant                    ,+++-- ** Label+    ActionLabelPropertyInfo                 ,+    constructActionLabel                    ,+    getActionLabel                          ,+    setActionLabel                          ,+++-- ** Name+    ActionNamePropertyInfo                  ,+    constructActionName                     ,+    getActionName                           ,+++-- ** Sensitive+    ActionSensitivePropertyInfo             ,+    constructActionSensitive                ,+    getActionSensitive                      ,+    setActionSensitive                      ,+++-- ** ShortLabel+    ActionShortLabelPropertyInfo            ,+    constructActionShortLabel               ,+    getActionShortLabel                     ,+    setActionShortLabel                     ,+++-- ** StockId+    ActionStockIdPropertyInfo               ,+    constructActionStockId                  ,+    getActionStockId                        ,+    setActionStockId                        ,+++-- ** Tooltip+    ActionTooltipPropertyInfo               ,+    constructActionTooltip                  ,+    getActionTooltip                        ,+    setActionTooltip                        ,+++-- ** Visible+    ActionVisiblePropertyInfo               ,+    constructActionVisible                  ,+    getActionVisible                        ,+    setActionVisible                        ,+++-- ** VisibleHorizontal+    ActionVisibleHorizontalPropertyInfo     ,+    constructActionVisibleHorizontal        ,+    getActionVisibleHorizontal              ,+    setActionVisibleHorizontal              ,+++-- ** VisibleOverflown+    ActionVisibleOverflownPropertyInfo      ,+    constructActionVisibleOverflown         ,+    getActionVisibleOverflown               ,+    setActionVisibleOverflown               ,+++-- ** VisibleVertical+    ActionVisibleVerticalPropertyInfo       ,+    constructActionVisibleVertical          ,+    getActionVisibleVertical                ,+    setActionVisibleVertical                ,+++++ -- * Signals+-- ** Activate+    ActionActivateCallback                  ,+    ActionActivateCallbackC                 ,+    ActionActivateSignalInfo                ,+    actionActivateCallbackWrapper           ,+    actionActivateClosure                   ,+    afterActionActivate                     ,+    mkActionActivateCallback                ,+    noActionActivateCallback                ,+    onActionActivate                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype Action = Action (ForeignPtr Action)+foreign import ccall "gtk_action_get_type"+    c_gtk_action_get_type :: IO GType++type instance ParentTypes Action = ActionParentTypes+type ActionParentTypes = '[GObject.Object, Buildable]++instance GObject Action where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_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++noAction :: Maybe Action+noAction = Nothing++-- signal Action::activate+type ActionActivateCallback =+    IO ()++noActionActivateCallback :: Maybe ActionActivateCallback+noActionActivateCallback = Nothing++type ActionActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionActivateCallback :: ActionActivateCallbackC -> IO (FunPtr ActionActivateCallbackC)++actionActivateClosure :: ActionActivateCallback -> IO Closure+actionActivateClosure cb = newCClosure =<< mkActionActivateCallback wrapped+    where wrapped = actionActivateCallbackWrapper cb++actionActivateCallbackWrapper ::+    ActionActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+actionActivateCallbackWrapper _cb _ _ = do+    _cb ++onActionActivate :: (GObject a, MonadIO m) => a -> ActionActivateCallback -> m SignalHandlerId+onActionActivate obj cb = liftIO $ connectActionActivate obj cb SignalConnectBefore+afterActionActivate :: (GObject a, MonadIO m) => a -> ActionActivateCallback -> m SignalHandlerId+afterActionActivate obj cb = connectActionActivate obj cb SignalConnectAfter++connectActionActivate :: (GObject a, MonadIO m) =>+                         a -> ActionActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectActionActivate obj cb after = liftIO $ do+    cb' <- mkActionActivateCallback (actionActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- VVV Prop "action-group"+   -- Type: TInterface "Gtk" "ActionGroup"+   -- Flags: [PropertyReadable,PropertyWritable]++getActionActionGroup :: (MonadIO m, ActionK o) => o -> m ActionGroup+getActionActionGroup obj = liftIO $ getObjectPropertyObject obj "action-group" ActionGroup++setActionActionGroup :: (MonadIO m, ActionK o, ActionGroupK a) => o -> a -> m ()+setActionActionGroup obj val = liftIO $ setObjectPropertyObject obj "action-group" val++constructActionActionGroup :: (ActionGroupK a) => a -> IO ([Char], GValue)+constructActionActionGroup val = constructObjectPropertyObject "action-group" val++data ActionActionGroupPropertyInfo+instance AttrInfo ActionActionGroupPropertyInfo where+    type AttrAllowedOps ActionActionGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionActionGroupPropertyInfo = ActionGroupK+    type AttrBaseTypeConstraint ActionActionGroupPropertyInfo = ActionK+    type AttrGetType ActionActionGroupPropertyInfo = ActionGroup+    type AttrLabel ActionActionGroupPropertyInfo = "Action::action-group"+    attrGet _ = getActionActionGroup+    attrSet _ = setActionActionGroup+    attrConstruct _ = constructActionActionGroup++-- VVV Prop "always-show-image"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getActionAlwaysShowImage :: (MonadIO m, ActionK o) => o -> m Bool+getActionAlwaysShowImage obj = liftIO $ getObjectPropertyBool obj "always-show-image"++setActionAlwaysShowImage :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionAlwaysShowImage obj val = liftIO $ setObjectPropertyBool obj "always-show-image" val++constructActionAlwaysShowImage :: Bool -> IO ([Char], GValue)+constructActionAlwaysShowImage val = constructObjectPropertyBool "always-show-image" val++data ActionAlwaysShowImagePropertyInfo+instance AttrInfo ActionAlwaysShowImagePropertyInfo where+    type AttrAllowedOps ActionAlwaysShowImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionAlwaysShowImagePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionAlwaysShowImagePropertyInfo = ActionK+    type AttrGetType ActionAlwaysShowImagePropertyInfo = Bool+    type AttrLabel ActionAlwaysShowImagePropertyInfo = "Action::always-show-image"+    attrGet _ = getActionAlwaysShowImage+    attrSet _ = setActionAlwaysShowImage+    attrConstruct _ = constructActionAlwaysShowImage++-- VVV Prop "gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getActionGicon :: (MonadIO m, ActionK o) => o -> m Gio.Icon+getActionGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Gio.Icon++setActionGicon :: (MonadIO m, ActionK o, Gio.IconK a) => o -> a -> m ()+setActionGicon obj val = liftIO $ setObjectPropertyObject obj "gicon" val++constructActionGicon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructActionGicon val = constructObjectPropertyObject "gicon" val++data ActionGiconPropertyInfo+instance AttrInfo ActionGiconPropertyInfo where+    type AttrAllowedOps ActionGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionGiconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint ActionGiconPropertyInfo = ActionK+    type AttrGetType ActionGiconPropertyInfo = Gio.Icon+    type AttrLabel ActionGiconPropertyInfo = "Action::gicon"+    attrGet _ = getActionGicon+    attrSet _ = setActionGicon+    attrConstruct _ = constructActionGicon++-- VVV Prop "hide-if-empty"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionHideIfEmpty :: (MonadIO m, ActionK o) => o -> m Bool+getActionHideIfEmpty obj = liftIO $ getObjectPropertyBool obj "hide-if-empty"++setActionHideIfEmpty :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionHideIfEmpty obj val = liftIO $ setObjectPropertyBool obj "hide-if-empty" val++constructActionHideIfEmpty :: Bool -> IO ([Char], GValue)+constructActionHideIfEmpty val = constructObjectPropertyBool "hide-if-empty" val++data ActionHideIfEmptyPropertyInfo+instance AttrInfo ActionHideIfEmptyPropertyInfo where+    type AttrAllowedOps ActionHideIfEmptyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionHideIfEmptyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionHideIfEmptyPropertyInfo = ActionK+    type AttrGetType ActionHideIfEmptyPropertyInfo = Bool+    type AttrLabel ActionHideIfEmptyPropertyInfo = "Action::hide-if-empty"+    attrGet _ = getActionHideIfEmpty+    attrSet _ = setActionHideIfEmpty+    attrConstruct _ = constructActionHideIfEmpty++-- VVV Prop "icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionIconName :: (MonadIO m, ActionK o) => o -> m T.Text+getActionIconName obj = liftIO $ getObjectPropertyString obj "icon-name"++setActionIconName :: (MonadIO m, ActionK o) => o -> T.Text -> m ()+setActionIconName obj val = liftIO $ setObjectPropertyString obj "icon-name" val++constructActionIconName :: T.Text -> IO ([Char], GValue)+constructActionIconName val = constructObjectPropertyString "icon-name" val++data ActionIconNamePropertyInfo+instance AttrInfo ActionIconNamePropertyInfo where+    type AttrAllowedOps ActionIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionIconNamePropertyInfo = ActionK+    type AttrGetType ActionIconNamePropertyInfo = T.Text+    type AttrLabel ActionIconNamePropertyInfo = "Action::icon-name"+    attrGet _ = getActionIconName+    attrSet _ = setActionIconName+    attrConstruct _ = constructActionIconName++-- VVV Prop "is-important"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionIsImportant :: (MonadIO m, ActionK o) => o -> m Bool+getActionIsImportant obj = liftIO $ getObjectPropertyBool obj "is-important"++setActionIsImportant :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionIsImportant obj val = liftIO $ setObjectPropertyBool obj "is-important" val++constructActionIsImportant :: Bool -> IO ([Char], GValue)+constructActionIsImportant val = constructObjectPropertyBool "is-important" val++data ActionIsImportantPropertyInfo+instance AttrInfo ActionIsImportantPropertyInfo where+    type AttrAllowedOps ActionIsImportantPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionIsImportantPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionIsImportantPropertyInfo = ActionK+    type AttrGetType ActionIsImportantPropertyInfo = Bool+    type AttrLabel ActionIsImportantPropertyInfo = "Action::is-important"+    attrGet _ = getActionIsImportant+    attrSet _ = setActionIsImportant+    attrConstruct _ = constructActionIsImportant++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionLabel :: (MonadIO m, ActionK o) => o -> m T.Text+getActionLabel obj = liftIO $ getObjectPropertyString obj "label"++setActionLabel :: (MonadIO m, ActionK o) => o -> T.Text -> m ()+setActionLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructActionLabel :: T.Text -> IO ([Char], GValue)+constructActionLabel val = constructObjectPropertyString "label" val++data ActionLabelPropertyInfo+instance AttrInfo ActionLabelPropertyInfo where+    type AttrAllowedOps ActionLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionLabelPropertyInfo = ActionK+    type AttrGetType ActionLabelPropertyInfo = T.Text+    type AttrLabel ActionLabelPropertyInfo = "Action::label"+    attrGet _ = getActionLabel+    attrSet _ = setActionLabel+    attrConstruct _ = constructActionLabel++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getActionName :: (MonadIO m, ActionK o) => o -> m T.Text+getActionName obj = liftIO $ getObjectPropertyString obj "name"++constructActionName :: T.Text -> IO ([Char], GValue)+constructActionName val = constructObjectPropertyString "name" val++data ActionNamePropertyInfo+instance AttrInfo ActionNamePropertyInfo where+    type AttrAllowedOps ActionNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionNamePropertyInfo = ActionK+    type AttrGetType ActionNamePropertyInfo = T.Text+    type AttrLabel ActionNamePropertyInfo = "Action::name"+    attrGet _ = getActionName+    attrSet _ = undefined+    attrConstruct _ = constructActionName++-- VVV Prop "sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionSensitive :: (MonadIO m, ActionK o) => o -> m Bool+getActionSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"++setActionSensitive :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val++constructActionSensitive :: Bool -> IO ([Char], GValue)+constructActionSensitive val = constructObjectPropertyBool "sensitive" val++data ActionSensitivePropertyInfo+instance AttrInfo ActionSensitivePropertyInfo where+    type AttrAllowedOps ActionSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionSensitivePropertyInfo = ActionK+    type AttrGetType ActionSensitivePropertyInfo = Bool+    type AttrLabel ActionSensitivePropertyInfo = "Action::sensitive"+    attrGet _ = getActionSensitive+    attrSet _ = setActionSensitive+    attrConstruct _ = constructActionSensitive++-- VVV Prop "short-label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionShortLabel :: (MonadIO m, ActionK o) => o -> m T.Text+getActionShortLabel obj = liftIO $ getObjectPropertyString obj "short-label"++setActionShortLabel :: (MonadIO m, ActionK o) => o -> T.Text -> m ()+setActionShortLabel obj val = liftIO $ setObjectPropertyString obj "short-label" val++constructActionShortLabel :: T.Text -> IO ([Char], GValue)+constructActionShortLabel val = constructObjectPropertyString "short-label" val++data ActionShortLabelPropertyInfo+instance AttrInfo ActionShortLabelPropertyInfo where+    type AttrAllowedOps ActionShortLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionShortLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionShortLabelPropertyInfo = ActionK+    type AttrGetType ActionShortLabelPropertyInfo = T.Text+    type AttrLabel ActionShortLabelPropertyInfo = "Action::short-label"+    attrGet _ = getActionShortLabel+    attrSet _ = setActionShortLabel+    attrConstruct _ = constructActionShortLabel++-- VVV Prop "stock-id"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionStockId :: (MonadIO m, ActionK o) => o -> m T.Text+getActionStockId obj = liftIO $ getObjectPropertyString obj "stock-id"++setActionStockId :: (MonadIO m, ActionK o) => o -> T.Text -> m ()+setActionStockId obj val = liftIO $ setObjectPropertyString obj "stock-id" val++constructActionStockId :: T.Text -> IO ([Char], GValue)+constructActionStockId val = constructObjectPropertyString "stock-id" val++data ActionStockIdPropertyInfo+instance AttrInfo ActionStockIdPropertyInfo where+    type AttrAllowedOps ActionStockIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionStockIdPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionStockIdPropertyInfo = ActionK+    type AttrGetType ActionStockIdPropertyInfo = T.Text+    type AttrLabel ActionStockIdPropertyInfo = "Action::stock-id"+    attrGet _ = getActionStockId+    attrSet _ = setActionStockId+    attrConstruct _ = constructActionStockId++-- VVV Prop "tooltip"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getActionTooltip :: (MonadIO m, ActionK o) => o -> m T.Text+getActionTooltip obj = liftIO $ getObjectPropertyString obj "tooltip"++setActionTooltip :: (MonadIO m, ActionK o) => o -> T.Text -> m ()+setActionTooltip obj val = liftIO $ setObjectPropertyString obj "tooltip" val++constructActionTooltip :: T.Text -> IO ([Char], GValue)+constructActionTooltip val = constructObjectPropertyString "tooltip" val++data ActionTooltipPropertyInfo+instance AttrInfo ActionTooltipPropertyInfo where+    type AttrAllowedOps ActionTooltipPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionTooltipPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionTooltipPropertyInfo = ActionK+    type AttrGetType ActionTooltipPropertyInfo = T.Text+    type AttrLabel ActionTooltipPropertyInfo = "Action::tooltip"+    attrGet _ = getActionTooltip+    attrSet _ = setActionTooltip+    attrConstruct _ = constructActionTooltip++-- VVV Prop "visible"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionVisible :: (MonadIO m, ActionK o) => o -> m Bool+getActionVisible obj = liftIO $ getObjectPropertyBool obj "visible"++setActionVisible :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val++constructActionVisible :: Bool -> IO ([Char], GValue)+constructActionVisible val = constructObjectPropertyBool "visible" val++data ActionVisiblePropertyInfo+instance AttrInfo ActionVisiblePropertyInfo where+    type AttrAllowedOps ActionVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionVisiblePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionVisiblePropertyInfo = ActionK+    type AttrGetType ActionVisiblePropertyInfo = Bool+    type AttrLabel ActionVisiblePropertyInfo = "Action::visible"+    attrGet _ = getActionVisible+    attrSet _ = setActionVisible+    attrConstruct _ = constructActionVisible++-- VVV Prop "visible-horizontal"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionVisibleHorizontal :: (MonadIO m, ActionK o) => o -> m Bool+getActionVisibleHorizontal obj = liftIO $ getObjectPropertyBool obj "visible-horizontal"++setActionVisibleHorizontal :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionVisibleHorizontal obj val = liftIO $ setObjectPropertyBool obj "visible-horizontal" val++constructActionVisibleHorizontal :: Bool -> IO ([Char], GValue)+constructActionVisibleHorizontal val = constructObjectPropertyBool "visible-horizontal" val++data ActionVisibleHorizontalPropertyInfo+instance AttrInfo ActionVisibleHorizontalPropertyInfo where+    type AttrAllowedOps ActionVisibleHorizontalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionVisibleHorizontalPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionVisibleHorizontalPropertyInfo = ActionK+    type AttrGetType ActionVisibleHorizontalPropertyInfo = Bool+    type AttrLabel ActionVisibleHorizontalPropertyInfo = "Action::visible-horizontal"+    attrGet _ = getActionVisibleHorizontal+    attrSet _ = setActionVisibleHorizontal+    attrConstruct _ = constructActionVisibleHorizontal++-- VVV Prop "visible-overflown"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionVisibleOverflown :: (MonadIO m, ActionK o) => o -> m Bool+getActionVisibleOverflown obj = liftIO $ getObjectPropertyBool obj "visible-overflown"++setActionVisibleOverflown :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionVisibleOverflown obj val = liftIO $ setObjectPropertyBool obj "visible-overflown" val++constructActionVisibleOverflown :: Bool -> IO ([Char], GValue)+constructActionVisibleOverflown val = constructObjectPropertyBool "visible-overflown" val++data ActionVisibleOverflownPropertyInfo+instance AttrInfo ActionVisibleOverflownPropertyInfo where+    type AttrAllowedOps ActionVisibleOverflownPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionVisibleOverflownPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionVisibleOverflownPropertyInfo = ActionK+    type AttrGetType ActionVisibleOverflownPropertyInfo = Bool+    type AttrLabel ActionVisibleOverflownPropertyInfo = "Action::visible-overflown"+    attrGet _ = getActionVisibleOverflown+    attrSet _ = setActionVisibleOverflown+    attrConstruct _ = constructActionVisibleOverflown++-- VVV Prop "visible-vertical"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionVisibleVertical :: (MonadIO m, ActionK o) => o -> m Bool+getActionVisibleVertical obj = liftIO $ getObjectPropertyBool obj "visible-vertical"++setActionVisibleVertical :: (MonadIO m, ActionK o) => o -> Bool -> m ()+setActionVisibleVertical obj val = liftIO $ setObjectPropertyBool obj "visible-vertical" val++constructActionVisibleVertical :: Bool -> IO ([Char], GValue)+constructActionVisibleVertical val = constructObjectPropertyBool "visible-vertical" val++data ActionVisibleVerticalPropertyInfo+instance AttrInfo ActionVisibleVerticalPropertyInfo where+    type AttrAllowedOps ActionVisibleVerticalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionVisibleVerticalPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionVisibleVerticalPropertyInfo = ActionK+    type AttrGetType ActionVisibleVerticalPropertyInfo = Bool+    type AttrLabel ActionVisibleVerticalPropertyInfo = "Action::visible-vertical"+    attrGet _ = getActionVisibleVertical+    attrSet _ = setActionVisibleVertical+    attrConstruct _ = constructActionVisibleVertical++type instance AttributeList Action = ActionAttributeList+type ActionAttributeList = ('[ '("action-group", ActionActionGroupPropertyInfo), '("always-show-image", ActionAlwaysShowImagePropertyInfo), '("gicon", ActionGiconPropertyInfo), '("hide-if-empty", ActionHideIfEmptyPropertyInfo), '("icon-name", ActionIconNamePropertyInfo), '("is-important", ActionIsImportantPropertyInfo), '("label", ActionLabelPropertyInfo), '("name", ActionNamePropertyInfo), '("sensitive", ActionSensitivePropertyInfo), '("short-label", ActionShortLabelPropertyInfo), '("stock-id", ActionStockIdPropertyInfo), '("tooltip", ActionTooltipPropertyInfo), '("visible", ActionVisiblePropertyInfo), '("visible-horizontal", ActionVisibleHorizontalPropertyInfo), '("visible-overflown", ActionVisibleOverflownPropertyInfo), '("visible-vertical", ActionVisibleVerticalPropertyInfo)] :: [(Symbol, *)])++data ActionActivateSignalInfo+instance SignalInfo ActionActivateSignalInfo where+    type HaskellCallbackType ActionActivateSignalInfo = ActionActivateCallback+    connectSignal _ = connectActionActivate++type instance SignalList Action = ActionSignalList+type ActionSignalList = ('[ '("activate", ActionActivateSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Action::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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, 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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_new" gtk_action_new :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- tooltip : TBasicType TUTF8+    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr Action)++{-# DEPRECATED actionNew ["(Since version 3.10)","Use #GAction instead, associating it to a widget with","#GtkActionable or creating a #GtkMenu with gtk_menu_new_from_model()"]#-}+actionNew ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- tooltip+    Maybe (T.Text) ->                       -- stock_id+    m Action+actionNew name label tooltip stock_id = liftIO $ do+    name' <- textToCString name+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    maybeStock_id <- case stock_id of+        Nothing -> return nullPtr+        Just jStock_id -> do+            jStock_id' <- textToCString jStock_id+            return jStock_id'+    result <- gtk_action_new name' maybeLabel maybeTooltip maybeStock_id+    checkUnexpectedReturnNULL "gtk_action_new" result+    result' <- (wrapObject Action) result+    freeMem name'+    freeMem maybeLabel+    freeMem maybeTooltip+    freeMem maybeStock_id+    return result'++-- method Action::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_activate" gtk_action_activate :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionActivate ["(Since version 3.10)","Use g_action_group_activate_action() on a #GAction instead"]#-}+actionActivate ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m ()+actionActivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_action_activate _obj'+    touchManagedPtr _obj+    return ()++-- method Action::block_activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_block_activate" gtk_action_block_activate :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionBlockActivate ["(Since version 3.10)","Use g_simple_action_set_enabled() to disable the","#GSimpleAction instead"]#-}+actionBlockActivate ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m ()+actionBlockActivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_action_block_activate _obj'+    touchManagedPtr _obj+    return ()++-- method Action::connect_accelerator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_connect_accelerator" gtk_action_connect_accelerator :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionConnectAccelerator ["(Since version 3.10)","Use #GAction and the accelerator group on an associated","#GtkMenu instead"]#-}+actionConnectAccelerator ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m ()+actionConnectAccelerator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_action_connect_accelerator _obj'+    touchManagedPtr _obj+    return ()++-- method Action::create_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_create_icon" gtk_action_create_icon :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    Int32 ->                                -- icon_size : TBasicType TInt32+    IO (Ptr Widget)++{-# DEPRECATED actionCreateIcon ["(Since version 3.10)","Use g_menu_item_set_icon() to set an icon on a #GMenuItem,","or gtk_container_add() to add a #GtkImage to a #GtkButton"]#-}+actionCreateIcon ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- icon_size+    m Widget+actionCreateIcon _obj icon_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_create_icon _obj' icon_size+    checkUnexpectedReturnNULL "gtk_action_create_icon" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Action::create_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_create_menu" gtk_action_create_menu :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr Widget)++{-# DEPRECATED actionCreateMenu ["(Since version 3.10)","Use #GAction and #GMenuModel instead, and create a","#GtkMenu with gtk_menu_new_from_model()"]#-}+actionCreateMenu ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Widget+actionCreateMenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_create_menu _obj'+    checkUnexpectedReturnNULL "gtk_action_create_menu" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Action::create_menu_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_create_menu_item" gtk_action_create_menu_item :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr Widget)++{-# DEPRECATED actionCreateMenuItem ["(Since version 3.10)","Use g_menu_item_new() and associate it with a #GAction","instead."]#-}+actionCreateMenuItem ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Widget+actionCreateMenuItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_create_menu_item _obj'+    checkUnexpectedReturnNULL "gtk_action_create_menu_item" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Action::create_tool_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_create_tool_item" gtk_action_create_tool_item :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr Widget)++{-# DEPRECATED actionCreateToolItem ["(Since version 3.10)","Use a #GtkToolItem and associate it with a #GAction using","gtk_actionable_set_action_name() instead"]#-}+actionCreateToolItem ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Widget+actionCreateToolItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_create_tool_item _obj'+    checkUnexpectedReturnNULL "gtk_action_create_tool_item" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Action::disconnect_accelerator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_disconnect_accelerator" gtk_action_disconnect_accelerator :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionDisconnectAccelerator ["(Since version 3.10)","Use #GAction and the accelerator group on an associated","#GtkMenu instead"]#-}+actionDisconnectAccelerator ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m ()+actionDisconnectAccelerator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_action_disconnect_accelerator _obj'+    touchManagedPtr _obj+    return ()++-- method Action::get_accel_closure+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Closure"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_accel_closure" gtk_action_get_accel_closure :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr Closure)++{-# DEPRECATED actionGetAccelClosure ["(Since version 3.10)","Use #GAction and #GtkMenu instead, which have no","equivalent for getting the accel closure"]#-}+actionGetAccelClosure ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Closure+actionGetAccelClosure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_accel_closure _obj'+    checkUnexpectedReturnNULL "gtk_action_get_accel_closure" result+    result' <- (newBoxed Closure) result+    touchManagedPtr _obj+    return result'++-- method Action::get_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_accel_path" gtk_action_get_accel_path :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetAccelPath ["(Since version 3.10)","Use #GAction and the accelerator path on an associated","#GtkMenu instead"]#-}+actionGetAccelPath ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetAccelPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_accel_path _obj'+    checkUnexpectedReturnNULL "gtk_action_get_accel_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_always_show_image" gtk_action_get_always_show_image :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetAlwaysShowImage ["(Since version 3.10)","Use g_menu_item_get_attribute_value() on a #GMenuItem","instead"]#-}+actionGetAlwaysShowImage ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetAlwaysShowImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_always_show_image _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_gicon" gtk_action_get_gicon :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr Gio.Icon)++{-# DEPRECATED actionGetGicon ["(Since version 3.10)","Use #GAction instead, and","g_menu_item_get_attribute_value() to get an icon from a #GMenuItem","associated with a #GAction"]#-}+actionGetGicon ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Gio.Icon+actionGetGicon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_gicon _obj'+    checkUnexpectedReturnNULL "gtk_action_get_gicon" result+    result' <- (newObject Gio.Icon) result+    touchManagedPtr _obj+    return result'++-- method Action::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_icon_name" gtk_action_get_icon_name :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetIconName ["(Since version 3.10)","Use #GAction instead, and","g_menu_item_get_attribute_value() to get an icon from a #GMenuItem","associated with a #GAction"]#-}+actionGetIconName ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetIconName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_icon_name _obj'+    checkUnexpectedReturnNULL "gtk_action_get_icon_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_is_important+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_is_important" gtk_action_get_is_important :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetIsImportant ["(Since version 3.10)","Use #GAction instead, and control and monitor whether","labels are shown directly"]#-}+actionGetIsImportant ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetIsImportant _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_is_important _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_label" gtk_action_get_label :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetLabel ["(Since version 3.10)","Use #GAction instead, and get a label from a menu item","with g_menu_item_get_attribute_value(). For #GtkActionable widgets, use the","widget-specific API to get a label"]#-}+actionGetLabel ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_label _obj'+    checkUnexpectedReturnNULL "gtk_action_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_name" gtk_action_get_name :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetName ["(Since version 3.10)","Use g_action_get_name() on a #GAction instead"]#-}+actionGetName ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_name _obj'+    checkUnexpectedReturnNULL "gtk_action_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_proxies+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "Widget")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_proxies" gtk_action_get_proxies :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO (Ptr (GSList (Ptr Widget)))++{-# DEPRECATED actionGetProxies ["(Since version 3.10)"]#-}+actionGetProxies ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m [Widget]+actionGetProxies _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_proxies _obj'+    checkUnexpectedReturnNULL "gtk_action_get_proxies" result+    result' <- unpackGSList result+    result'' <- mapM (newObject Widget) result'+    touchManagedPtr _obj+    return result''++-- method Action::get_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_sensitive" gtk_action_get_sensitive :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetSensitive ["(Since version 3.10)","Use g_action_get_enabled() on a #GAction","instead"]#-}+actionGetSensitive ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetSensitive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_sensitive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_short_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_short_label" gtk_action_get_short_label :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetShortLabel ["(Since version 3.10)","Use #GAction instead, which has no equivalent of short","labels"]#-}+actionGetShortLabel ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetShortLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_short_label _obj'+    checkUnexpectedReturnNULL "gtk_action_get_short_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_stock_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_stock_id" gtk_action_get_stock_id :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetStockId ["(Since version 3.10)","Use #GAction instead, which has no equivalent of stock","items"]#-}+actionGetStockId ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetStockId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_stock_id _obj'+    checkUnexpectedReturnNULL "gtk_action_get_stock_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_tooltip+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_tooltip" gtk_action_get_tooltip :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CString++{-# DEPRECATED actionGetTooltip ["(Since version 3.10)","Use #GAction instead, and get tooltips from associated","#GtkActionable widgets with gtk_widget_get_tooltip_text()"]#-}+actionGetTooltip ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m T.Text+actionGetTooltip _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_tooltip _obj'+    checkUnexpectedReturnNULL "gtk_action_get_tooltip" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Action::get_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_visible" gtk_action_get_visible :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetVisible ["(Since version 3.10)","Use #GAction instead, and control and monitor the state of","#GtkActionable widgets directly"]#-}+actionGetVisible ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetVisible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_visible _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_visible_horizontal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_visible_horizontal" gtk_action_get_visible_horizontal :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetVisibleHorizontal ["(Since version 3.10)","Use #GAction instead, and control and monitor the","visibility of associated widgets and menu items directly"]#-}+actionGetVisibleHorizontal ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetVisibleHorizontal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_visible_horizontal _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::get_visible_vertical+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_get_visible_vertical" gtk_action_get_visible_vertical :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionGetVisibleVertical ["(Since version 3.10)","Use #GAction instead, and control and monitor the","visibility of associated widgets and menu items directly"]#-}+actionGetVisibleVertical ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionGetVisibleVertical _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_get_visible_vertical _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::is_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_is_sensitive" gtk_action_is_sensitive :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionIsSensitive ["(Since version 3.10)","Use g_action_get_enabled() on a #GAction","instead"]#-}+actionIsSensitive ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionIsSensitive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_is_sensitive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::is_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_is_visible" gtk_action_is_visible :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO CInt++{-# DEPRECATED actionIsVisible ["(Since version 3.10)","Use #GAction instead, and control and monitor the state of","#GtkActionable widgets directly"]#-}+actionIsVisible ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m Bool+actionIsVisible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_is_visible _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Action::set_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_set_accel_group" gtk_action_set_accel_group :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    Ptr AccelGroup ->                       -- accel_group : TInterface "Gtk" "AccelGroup"+    IO ()++{-# DEPRECATED actionSetAccelGroup ["(Since version 3.10)","Use #GAction and the accelerator group on an associated","#GtkMenu instead"]#-}+actionSetAccelGroup ::+    (MonadIO m, ActionK a, AccelGroupK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- accel_group+    m ()+actionSetAccelGroup _obj accel_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAccel_group <- case accel_group of+        Nothing -> return nullPtr+        Just jAccel_group -> do+            let jAccel_group' = unsafeManagedPtrCastPtr jAccel_group+            return jAccel_group'+    gtk_action_set_accel_group _obj' maybeAccel_group+    touchManagedPtr _obj+    whenJust accel_group touchManagedPtr+    return ()++-- method Action::set_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_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 "gtk_action_set_accel_path" gtk_action_set_accel_path :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- accel_path : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetAccelPath ["(Since version 3.10)","Use #GAction and the accelerator path on an associated","#GtkMenu instead"]#-}+actionSetAccelPath ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- accel_path+    m ()+actionSetAccelPath _obj accel_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    accel_path' <- textToCString accel_path+    gtk_action_set_accel_path _obj' accel_path'+    touchManagedPtr _obj+    freeMem accel_path'+    return ()++-- method Action::set_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", 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 "gtk_action_set_always_show_image" gtk_action_set_always_show_image :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- always_show : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetAlwaysShowImage ["(Since version 3.10)","Use g_menu_item_set_icon() on a #GMenuItem instead, if the","item should have an image"]#-}+actionSetAlwaysShowImage ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- always_show+    m ()+actionSetAlwaysShowImage _obj always_show = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let always_show' = (fromIntegral . fromEnum) always_show+    gtk_action_set_always_show_image _obj' always_show'+    touchManagedPtr _obj+    return ()++-- method Action::set_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", 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 "Gtk" "Action", 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 "gtk_action_set_gicon" gtk_action_set_gicon :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    IO ()++{-# DEPRECATED actionSetGicon ["(Since version 3.10)","Use #GAction instead, and g_menu_item_set_icon() to set an","icon on a #GMenuItem associated with a #GAction, or gtk_container_add() to","add a #GtkImage to a #GtkButton"]#-}+actionSetGicon ::+    (MonadIO m, ActionK a, Gio.IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    m ()+actionSetGicon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    gtk_action_set_gicon _obj' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method Action::set_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_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 "gtk_action_set_icon_name" gtk_action_set_icon_name :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetIconName ["(Since version 3.10)","Use #GAction instead, and g_menu_item_set_icon() to set an","icon on a #GMenuItem associated with a #GAction, or gtk_container_add() to","add a #GtkImage to a #GtkButton"]#-}+actionSetIconName ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    m ()+actionSetIconName _obj icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    gtk_action_set_icon_name _obj' icon_name'+    touchManagedPtr _obj+    freeMem icon_name'+    return ()++-- method Action::set_is_important+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_important", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_important", 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 "gtk_action_set_is_important" gtk_action_set_is_important :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- is_important : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetIsImportant ["(Since version 3.10)","Use #GAction instead, and control and monitor whether","labels are shown directly"]#-}+actionSetIsImportant ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_important+    m ()+actionSetIsImportant _obj is_important = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_important' = (fromIntegral . fromEnum) is_important+    gtk_action_set_is_important _obj' is_important'+    touchManagedPtr _obj+    return ()++-- method Action::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_set_label" gtk_action_set_label :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- label : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetLabel ["(Since version 3.10)","Use #GAction instead, and set a label on a menu item with","g_menu_item_set_label(). For #GtkActionable widgets, use the widget-specific","API to set a label"]#-}+actionSetLabel ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    m ()+actionSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    gtk_action_set_label _obj' label'+    touchManagedPtr _obj+    freeMem label'+    return ()++-- method Action::set_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", 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 "gtk_action_set_sensitive" gtk_action_set_sensitive :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- sensitive : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetSensitive ["(Since version 3.10)","Use g_simple_action_set_enabled() on a #GSimpleAction","instead"]#-}+actionSetSensitive ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- sensitive+    m ()+actionSetSensitive _obj sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitive' = (fromIntegral . fromEnum) sensitive+    gtk_action_set_sensitive _obj' sensitive'+    touchManagedPtr _obj+    return ()++-- method Action::set_short_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "short_label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "short_label", 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 "gtk_action_set_short_label" gtk_action_set_short_label :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- short_label : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetShortLabel ["(Since version 3.10)","Use #GAction instead, which has no equivalent of short","labels"]#-}+actionSetShortLabel ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- short_label+    m ()+actionSetShortLabel _obj short_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    short_label' <- textToCString short_label+    gtk_action_set_short_label _obj' short_label'+    touchManagedPtr _obj+    freeMem short_label'+    return ()++-- method Action::set_stock_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_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 "gtk_action_set_stock_id" gtk_action_set_stock_id :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- stock_id : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetStockId ["(Since version 3.10)","Use #GAction instead, which has no equivalent of stock","items"]#-}+actionSetStockId ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- stock_id+    m ()+actionSetStockId _obj stock_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stock_id' <- textToCString stock_id+    gtk_action_set_stock_id _obj' stock_id'+    touchManagedPtr _obj+    freeMem stock_id'+    return ()++-- method Action::set_tooltip+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", 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 "gtk_action_set_tooltip" gtk_action_set_tooltip :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CString ->                              -- tooltip : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionSetTooltip ["(Since version 3.10)","Use #GAction instead, and set tooltips on associated","#GtkActionable widgets with gtk_widget_set_tooltip_text()"]#-}+actionSetTooltip ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- tooltip+    m ()+actionSetTooltip _obj tooltip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    tooltip' <- textToCString tooltip+    gtk_action_set_tooltip _obj' tooltip'+    touchManagedPtr _obj+    freeMem tooltip'+    return ()++-- method Action::set_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", 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 "gtk_action_set_visible" gtk_action_set_visible :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- visible : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetVisible ["(Since version 3.10)","Use #GAction instead, and control and monitor the state of","#GtkActionable widgets directly"]#-}+actionSetVisible ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible+    m ()+actionSetVisible _obj visible = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible' = (fromIntegral . fromEnum) visible+    gtk_action_set_visible _obj' visible'+    touchManagedPtr _obj+    return ()++-- method Action::set_visible_horizontal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_horizontal", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_horizontal", 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 "gtk_action_set_visible_horizontal" gtk_action_set_visible_horizontal :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- visible_horizontal : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetVisibleHorizontal ["(Since version 3.10)","Use #GAction instead, and control and monitor the","visibility of associated widgets and menu items directly"]#-}+actionSetVisibleHorizontal ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible_horizontal+    m ()+actionSetVisibleHorizontal _obj visible_horizontal = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible_horizontal' = (fromIntegral . fromEnum) visible_horizontal+    gtk_action_set_visible_horizontal _obj' visible_horizontal'+    touchManagedPtr _obj+    return ()++-- method Action::set_visible_vertical+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_vertical", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_vertical", 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 "gtk_action_set_visible_vertical" gtk_action_set_visible_vertical :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    CInt ->                                 -- visible_vertical : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionSetVisibleVertical ["(Since version 3.10)","Use #GAction instead, and control and monitor the","visibility of associated widgets and menu items directly"]#-}+actionSetVisibleVertical ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible_vertical+    m ()+actionSetVisibleVertical _obj visible_vertical = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible_vertical' = (fromIntegral . fromEnum) visible_vertical+    gtk_action_set_visible_vertical _obj' visible_vertical'+    touchManagedPtr _obj+    return ()++-- method Action::unblock_activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_unblock_activate" gtk_action_unblock_activate :: +    Ptr Action ->                           -- _obj : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionUnblockActivate ["(Since version 3.10)","Use g_simple_action_set_enabled() to enable the","#GSimpleAction instead"]#-}+actionUnblockActivate ::+    (MonadIO m, ActionK a) =>+    a ->                                    -- _obj+    m ()+actionUnblockActivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_action_unblock_activate _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Action.hs-boot view
@@ -0,0 +1,30 @@+module GI.Gtk.Objects.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)+instance GObject Action where+class GObject o => ActionK o+instance (GObject o, IsDescendantOf Action o) => ActionK o+data ActionActionGroupPropertyInfo+data ActionAlwaysShowImagePropertyInfo+data ActionGiconPropertyInfo+data ActionHideIfEmptyPropertyInfo+data ActionIconNamePropertyInfo+data ActionIsImportantPropertyInfo+data ActionLabelPropertyInfo+data ActionNamePropertyInfo+data ActionSensitivePropertyInfo+data ActionShortLabelPropertyInfo+data ActionStockIdPropertyInfo+data ActionTooltipPropertyInfo+data ActionVisiblePropertyInfo+data ActionVisibleHorizontalPropertyInfo+data ActionVisibleOverflownPropertyInfo+data ActionVisibleVerticalPropertyInfo+data ActionActivateSignalInfo
+ GI/Gtk/Objects/ActionBar.hs view
@@ -0,0 +1,218 @@++{- |+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.Gtk.Objects.ActionBar+    ( ++-- * Exported types+    ActionBar(..)                           ,+    ActionBarK                              ,+    toActionBar                             ,+    noActionBar                             ,+++ -- * Methods+-- ** actionBarGetCenterWidget+    actionBarGetCenterWidget                ,+++-- ** actionBarNew+    actionBarNew                            ,+++-- ** actionBarPackEnd+    actionBarPackEnd                        ,+++-- ** actionBarPackStart+    actionBarPackStart                      ,+++-- ** actionBarSetCenterWidget+    actionBarSetCenterWidget                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ActionBar = ActionBar (ForeignPtr ActionBar)+foreign import ccall "gtk_action_bar_get_type"+    c_gtk_action_bar_get_type :: IO GType++type instance ParentTypes ActionBar = ActionBarParentTypes+type ActionBarParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject ActionBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_action_bar_get_type+    ++class GObject o => ActionBarK o+instance (GObject o, IsDescendantOf ActionBar o) => ActionBarK o++toActionBar :: ActionBarK o => o -> IO ActionBar+toActionBar = unsafeCastTo ActionBar++noActionBar :: Maybe ActionBar+noActionBar = Nothing++type instance AttributeList ActionBar = ActionBarAttributeList+type ActionBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ActionBar = ActionBarSignalList+type ActionBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ActionBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ActionBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_bar_new" gtk_action_bar_new :: +    IO (Ptr ActionBar)+++actionBarNew ::+    (MonadIO m) =>+    m ActionBar+actionBarNew  = liftIO $ do+    result <- gtk_action_bar_new+    checkUnexpectedReturnNULL "gtk_action_bar_new" result+    result' <- (newObject ActionBar) result+    return result'++-- method ActionBar::get_center_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_bar_get_center_widget" gtk_action_bar_get_center_widget :: +    Ptr ActionBar ->                        -- _obj : TInterface "Gtk" "ActionBar"+    IO (Ptr Widget)+++actionBarGetCenterWidget ::+    (MonadIO m, ActionBarK a) =>+    a ->                                    -- _obj+    m Widget+actionBarGetCenterWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_bar_get_center_widget _obj'+    checkUnexpectedReturnNULL "gtk_action_bar_get_center_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method ActionBar::pack_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_bar_pack_end" gtk_action_bar_pack_end :: +    Ptr ActionBar ->                        -- _obj : TInterface "Gtk" "ActionBar"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++actionBarPackEnd ::+    (MonadIO m, ActionBarK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+actionBarPackEnd _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_action_bar_pack_end _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ActionBar::pack_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_bar_pack_start" gtk_action_bar_pack_start :: +    Ptr ActionBar ->                        -- _obj : TInterface "Gtk" "ActionBar"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++actionBarPackStart ::+    (MonadIO m, ActionBarK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+actionBarPackStart _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_action_bar_pack_start _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ActionBar::set_center_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "center_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "center_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_bar_set_center_widget" gtk_action_bar_set_center_widget :: +    Ptr ActionBar ->                        -- _obj : TInterface "Gtk" "ActionBar"+    Ptr Widget ->                           -- center_widget : TInterface "Gtk" "Widget"+    IO ()+++actionBarSetCenterWidget ::+    (MonadIO m, ActionBarK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- center_widget+    m ()+actionBarSetCenterWidget _obj center_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCenter_widget <- case center_widget of+        Nothing -> return nullPtr+        Just jCenter_widget -> do+            let jCenter_widget' = unsafeManagedPtrCastPtr jCenter_widget+            return jCenter_widget'+    gtk_action_bar_set_center_widget _obj' maybeCenter_widget+    touchManagedPtr _obj+    whenJust center_widget touchManagedPtr+    return ()++
+ GI/Gtk/Objects/ActionBar.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ActionBar where++import Prelude ()+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 ActionBar = ActionBar (ForeignPtr ActionBar)+instance GObject ActionBar where+class GObject o => ActionBarK o+instance (GObject o, IsDescendantOf ActionBar o) => ActionBarK o
+ GI/Gtk/Objects/ActionGroup.hs view
@@ -0,0 +1,953 @@++{- |+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.Gtk.Objects.ActionGroup+    ( ++-- * Exported types+    ActionGroup(..)                         ,+    ActionGroupK                            ,+    toActionGroup                           ,+    noActionGroup                           ,+++ -- * Methods+-- ** actionGroupAddAction+    actionGroupAddAction                    ,+++-- ** actionGroupAddActionWithAccel+    actionGroupAddActionWithAccel           ,+++-- ** actionGroupGetAccelGroup+    actionGroupGetAccelGroup                ,+++-- ** actionGroupGetAction+    actionGroupGetAction                    ,+++-- ** actionGroupGetName+    actionGroupGetName                      ,+++-- ** actionGroupGetSensitive+    actionGroupGetSensitive                 ,+++-- ** actionGroupGetVisible+    actionGroupGetVisible                   ,+++-- ** actionGroupListActions+    actionGroupListActions                  ,+++-- ** actionGroupNew+    actionGroupNew                          ,+++-- ** actionGroupRemoveAction+    actionGroupRemoveAction                 ,+++-- ** actionGroupSetAccelGroup+    actionGroupSetAccelGroup                ,+++-- ** actionGroupSetSensitive+    actionGroupSetSensitive                 ,+++-- ** actionGroupSetTranslateFunc+    actionGroupSetTranslateFunc             ,+++-- ** actionGroupSetTranslationDomain+    actionGroupSetTranslationDomain         ,+++-- ** actionGroupSetVisible+    actionGroupSetVisible                   ,+++-- ** actionGroupTranslateString+    actionGroupTranslateString              ,+++++ -- * Properties+-- ** AccelGroup+    ActionGroupAccelGroupPropertyInfo       ,+    constructActionGroupAccelGroup          ,+    getActionGroupAccelGroup                ,+    setActionGroupAccelGroup                ,+++-- ** Name+    ActionGroupNamePropertyInfo             ,+    constructActionGroupName                ,+    getActionGroupName                      ,+++-- ** Sensitive+    ActionGroupSensitivePropertyInfo        ,+    constructActionGroupSensitive           ,+    getActionGroupSensitive                 ,+    setActionGroupSensitive                 ,+++-- ** Visible+    ActionGroupVisiblePropertyInfo          ,+    constructActionGroupVisible             ,+    getActionGroupVisible                   ,+    setActionGroupVisible                   ,+++++ -- * Signals+-- ** ConnectProxy+    ActionGroupConnectProxyCallback         ,+    ActionGroupConnectProxyCallbackC        ,+    ActionGroupConnectProxySignalInfo       ,+    actionGroupConnectProxyCallbackWrapper  ,+    actionGroupConnectProxyClosure          ,+    afterActionGroupConnectProxy            ,+    mkActionGroupConnectProxyCallback       ,+    noActionGroupConnectProxyCallback       ,+    onActionGroupConnectProxy               ,+++-- ** DisconnectProxy+    ActionGroupDisconnectProxyCallback      ,+    ActionGroupDisconnectProxyCallbackC     ,+    ActionGroupDisconnectProxySignalInfo    ,+    actionGroupDisconnectProxyCallbackWrapper,+    actionGroupDisconnectProxyClosure       ,+    afterActionGroupDisconnectProxy         ,+    mkActionGroupDisconnectProxyCallback    ,+    noActionGroupDisconnectProxyCallback    ,+    onActionGroupDisconnectProxy            ,+++-- ** PostActivate+    ActionGroupPostActivateCallback         ,+    ActionGroupPostActivateCallbackC        ,+    ActionGroupPostActivateSignalInfo       ,+    actionGroupPostActivateCallbackWrapper  ,+    actionGroupPostActivateClosure          ,+    afterActionGroupPostActivate            ,+    mkActionGroupPostActivateCallback       ,+    noActionGroupPostActivateCallback       ,+    onActionGroupPostActivate               ,+++-- ** PreActivate+    ActionGroupPreActivateCallback          ,+    ActionGroupPreActivateCallbackC         ,+    ActionGroupPreActivateSignalInfo        ,+    actionGroupPreActivateCallbackWrapper   ,+    actionGroupPreActivateClosure           ,+    afterActionGroupPreActivate             ,+    mkActionGroupPreActivateCallback        ,+    noActionGroupPreActivateCallback        ,+    onActionGroupPreActivate                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype ActionGroup = ActionGroup (ForeignPtr ActionGroup)+foreign import ccall "gtk_action_group_get_type"+    c_gtk_action_group_get_type :: IO GType++type instance ParentTypes ActionGroup = ActionGroupParentTypes+type ActionGroupParentTypes = '[GObject.Object, Buildable]++instance GObject ActionGroup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_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++noActionGroup :: Maybe ActionGroup+noActionGroup = Nothing++-- signal ActionGroup::connect-proxy+type ActionGroupConnectProxyCallback =+    Action ->+    Widget ->+    IO ()++noActionGroupConnectProxyCallback :: Maybe ActionGroupConnectProxyCallback+noActionGroupConnectProxyCallback = Nothing++type ActionGroupConnectProxyCallbackC =+    Ptr () ->                               -- object+    Ptr Action ->+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupConnectProxyCallback :: ActionGroupConnectProxyCallbackC -> IO (FunPtr ActionGroupConnectProxyCallbackC)++actionGroupConnectProxyClosure :: ActionGroupConnectProxyCallback -> IO Closure+actionGroupConnectProxyClosure cb = newCClosure =<< mkActionGroupConnectProxyCallback wrapped+    where wrapped = actionGroupConnectProxyCallbackWrapper cb++actionGroupConnectProxyCallbackWrapper ::+    ActionGroupConnectProxyCallback ->+    Ptr () ->+    Ptr Action ->+    Ptr Widget ->+    Ptr () ->+    IO ()+actionGroupConnectProxyCallbackWrapper _cb _ action proxy _ = do+    action' <- (newObject Action) action+    proxy' <- (newObject Widget) proxy+    _cb  action' proxy'++onActionGroupConnectProxy :: (GObject a, MonadIO m) => a -> ActionGroupConnectProxyCallback -> m SignalHandlerId+onActionGroupConnectProxy obj cb = liftIO $ connectActionGroupConnectProxy obj cb SignalConnectBefore+afterActionGroupConnectProxy :: (GObject a, MonadIO m) => a -> ActionGroupConnectProxyCallback -> m SignalHandlerId+afterActionGroupConnectProxy obj cb = connectActionGroupConnectProxy obj cb SignalConnectAfter++connectActionGroupConnectProxy :: (GObject a, MonadIO m) =>+                                  a -> ActionGroupConnectProxyCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupConnectProxy obj cb after = liftIO $ do+    cb' <- mkActionGroupConnectProxyCallback (actionGroupConnectProxyCallbackWrapper cb)+    connectSignalFunPtr obj "connect-proxy" cb' after++-- signal ActionGroup::disconnect-proxy+type ActionGroupDisconnectProxyCallback =+    Action ->+    Widget ->+    IO ()++noActionGroupDisconnectProxyCallback :: Maybe ActionGroupDisconnectProxyCallback+noActionGroupDisconnectProxyCallback = Nothing++type ActionGroupDisconnectProxyCallbackC =+    Ptr () ->                               -- object+    Ptr Action ->+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupDisconnectProxyCallback :: ActionGroupDisconnectProxyCallbackC -> IO (FunPtr ActionGroupDisconnectProxyCallbackC)++actionGroupDisconnectProxyClosure :: ActionGroupDisconnectProxyCallback -> IO Closure+actionGroupDisconnectProxyClosure cb = newCClosure =<< mkActionGroupDisconnectProxyCallback wrapped+    where wrapped = actionGroupDisconnectProxyCallbackWrapper cb++actionGroupDisconnectProxyCallbackWrapper ::+    ActionGroupDisconnectProxyCallback ->+    Ptr () ->+    Ptr Action ->+    Ptr Widget ->+    Ptr () ->+    IO ()+actionGroupDisconnectProxyCallbackWrapper _cb _ action proxy _ = do+    action' <- (newObject Action) action+    proxy' <- (newObject Widget) proxy+    _cb  action' proxy'++onActionGroupDisconnectProxy :: (GObject a, MonadIO m) => a -> ActionGroupDisconnectProxyCallback -> m SignalHandlerId+onActionGroupDisconnectProxy obj cb = liftIO $ connectActionGroupDisconnectProxy obj cb SignalConnectBefore+afterActionGroupDisconnectProxy :: (GObject a, MonadIO m) => a -> ActionGroupDisconnectProxyCallback -> m SignalHandlerId+afterActionGroupDisconnectProxy obj cb = connectActionGroupDisconnectProxy obj cb SignalConnectAfter++connectActionGroupDisconnectProxy :: (GObject a, MonadIO m) =>+                                     a -> ActionGroupDisconnectProxyCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupDisconnectProxy obj cb after = liftIO $ do+    cb' <- mkActionGroupDisconnectProxyCallback (actionGroupDisconnectProxyCallbackWrapper cb)+    connectSignalFunPtr obj "disconnect-proxy" cb' after++-- signal ActionGroup::post-activate+type ActionGroupPostActivateCallback =+    Action ->+    IO ()++noActionGroupPostActivateCallback :: Maybe ActionGroupPostActivateCallback+noActionGroupPostActivateCallback = Nothing++type ActionGroupPostActivateCallbackC =+    Ptr () ->                               -- object+    Ptr Action ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupPostActivateCallback :: ActionGroupPostActivateCallbackC -> IO (FunPtr ActionGroupPostActivateCallbackC)++actionGroupPostActivateClosure :: ActionGroupPostActivateCallback -> IO Closure+actionGroupPostActivateClosure cb = newCClosure =<< mkActionGroupPostActivateCallback wrapped+    where wrapped = actionGroupPostActivateCallbackWrapper cb++actionGroupPostActivateCallbackWrapper ::+    ActionGroupPostActivateCallback ->+    Ptr () ->+    Ptr Action ->+    Ptr () ->+    IO ()+actionGroupPostActivateCallbackWrapper _cb _ action _ = do+    action' <- (newObject Action) action+    _cb  action'++onActionGroupPostActivate :: (GObject a, MonadIO m) => a -> ActionGroupPostActivateCallback -> m SignalHandlerId+onActionGroupPostActivate obj cb = liftIO $ connectActionGroupPostActivate obj cb SignalConnectBefore+afterActionGroupPostActivate :: (GObject a, MonadIO m) => a -> ActionGroupPostActivateCallback -> m SignalHandlerId+afterActionGroupPostActivate obj cb = connectActionGroupPostActivate obj cb SignalConnectAfter++connectActionGroupPostActivate :: (GObject a, MonadIO m) =>+                                  a -> ActionGroupPostActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupPostActivate obj cb after = liftIO $ do+    cb' <- mkActionGroupPostActivateCallback (actionGroupPostActivateCallbackWrapper cb)+    connectSignalFunPtr obj "post-activate" cb' after++-- signal ActionGroup::pre-activate+type ActionGroupPreActivateCallback =+    Action ->+    IO ()++noActionGroupPreActivateCallback :: Maybe ActionGroupPreActivateCallback+noActionGroupPreActivateCallback = Nothing++type ActionGroupPreActivateCallbackC =+    Ptr () ->                               -- object+    Ptr Action ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkActionGroupPreActivateCallback :: ActionGroupPreActivateCallbackC -> IO (FunPtr ActionGroupPreActivateCallbackC)++actionGroupPreActivateClosure :: ActionGroupPreActivateCallback -> IO Closure+actionGroupPreActivateClosure cb = newCClosure =<< mkActionGroupPreActivateCallback wrapped+    where wrapped = actionGroupPreActivateCallbackWrapper cb++actionGroupPreActivateCallbackWrapper ::+    ActionGroupPreActivateCallback ->+    Ptr () ->+    Ptr Action ->+    Ptr () ->+    IO ()+actionGroupPreActivateCallbackWrapper _cb _ action _ = do+    action' <- (newObject Action) action+    _cb  action'++onActionGroupPreActivate :: (GObject a, MonadIO m) => a -> ActionGroupPreActivateCallback -> m SignalHandlerId+onActionGroupPreActivate obj cb = liftIO $ connectActionGroupPreActivate obj cb SignalConnectBefore+afterActionGroupPreActivate :: (GObject a, MonadIO m) => a -> ActionGroupPreActivateCallback -> m SignalHandlerId+afterActionGroupPreActivate obj cb = connectActionGroupPreActivate obj cb SignalConnectAfter++connectActionGroupPreActivate :: (GObject a, MonadIO m) =>+                                 a -> ActionGroupPreActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectActionGroupPreActivate obj cb after = liftIO $ do+    cb' <- mkActionGroupPreActivateCallback (actionGroupPreActivateCallbackWrapper cb)+    connectSignalFunPtr obj "pre-activate" cb' after++-- VVV Prop "accel-group"+   -- Type: TInterface "Gtk" "AccelGroup"+   -- Flags: [PropertyReadable,PropertyWritable]++getActionGroupAccelGroup :: (MonadIO m, ActionGroupK o) => o -> m AccelGroup+getActionGroupAccelGroup obj = liftIO $ getObjectPropertyObject obj "accel-group" AccelGroup++setActionGroupAccelGroup :: (MonadIO m, ActionGroupK o, AccelGroupK a) => o -> a -> m ()+setActionGroupAccelGroup obj val = liftIO $ setObjectPropertyObject obj "accel-group" val++constructActionGroupAccelGroup :: (AccelGroupK a) => a -> IO ([Char], GValue)+constructActionGroupAccelGroup val = constructObjectPropertyObject "accel-group" val++data ActionGroupAccelGroupPropertyInfo+instance AttrInfo ActionGroupAccelGroupPropertyInfo where+    type AttrAllowedOps ActionGroupAccelGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionGroupAccelGroupPropertyInfo = AccelGroupK+    type AttrBaseTypeConstraint ActionGroupAccelGroupPropertyInfo = ActionGroupK+    type AttrGetType ActionGroupAccelGroupPropertyInfo = AccelGroup+    type AttrLabel ActionGroupAccelGroupPropertyInfo = "ActionGroup::accel-group"+    attrGet _ = getActionGroupAccelGroup+    attrSet _ = setActionGroupAccelGroup+    attrConstruct _ = constructActionGroupAccelGroup++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getActionGroupName :: (MonadIO m, ActionGroupK o) => o -> m T.Text+getActionGroupName obj = liftIO $ getObjectPropertyString obj "name"++constructActionGroupName :: T.Text -> IO ([Char], GValue)+constructActionGroupName val = constructObjectPropertyString "name" val++data ActionGroupNamePropertyInfo+instance AttrInfo ActionGroupNamePropertyInfo where+    type AttrAllowedOps ActionGroupNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionGroupNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ActionGroupNamePropertyInfo = ActionGroupK+    type AttrGetType ActionGroupNamePropertyInfo = T.Text+    type AttrLabel ActionGroupNamePropertyInfo = "ActionGroup::name"+    attrGet _ = getActionGroupName+    attrSet _ = undefined+    attrConstruct _ = constructActionGroupName++-- VVV Prop "sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionGroupSensitive :: (MonadIO m, ActionGroupK o) => o -> m Bool+getActionGroupSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"++setActionGroupSensitive :: (MonadIO m, ActionGroupK o) => o -> Bool -> m ()+setActionGroupSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val++constructActionGroupSensitive :: Bool -> IO ([Char], GValue)+constructActionGroupSensitive val = constructObjectPropertyBool "sensitive" val++data ActionGroupSensitivePropertyInfo+instance AttrInfo ActionGroupSensitivePropertyInfo where+    type AttrAllowedOps ActionGroupSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionGroupSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionGroupSensitivePropertyInfo = ActionGroupK+    type AttrGetType ActionGroupSensitivePropertyInfo = Bool+    type AttrLabel ActionGroupSensitivePropertyInfo = "ActionGroup::sensitive"+    attrGet _ = getActionGroupSensitive+    attrSet _ = setActionGroupSensitive+    attrConstruct _ = constructActionGroupSensitive++-- VVV Prop "visible"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getActionGroupVisible :: (MonadIO m, ActionGroupK o) => o -> m Bool+getActionGroupVisible obj = liftIO $ getObjectPropertyBool obj "visible"++setActionGroupVisible :: (MonadIO m, ActionGroupK o) => o -> Bool -> m ()+setActionGroupVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val++constructActionGroupVisible :: Bool -> IO ([Char], GValue)+constructActionGroupVisible val = constructObjectPropertyBool "visible" val++data ActionGroupVisiblePropertyInfo+instance AttrInfo ActionGroupVisiblePropertyInfo where+    type AttrAllowedOps ActionGroupVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ActionGroupVisiblePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ActionGroupVisiblePropertyInfo = ActionGroupK+    type AttrGetType ActionGroupVisiblePropertyInfo = Bool+    type AttrLabel ActionGroupVisiblePropertyInfo = "ActionGroup::visible"+    attrGet _ = getActionGroupVisible+    attrSet _ = setActionGroupVisible+    attrConstruct _ = constructActionGroupVisible++type instance AttributeList ActionGroup = ActionGroupAttributeList+type ActionGroupAttributeList = ('[ '("accel-group", ActionGroupAccelGroupPropertyInfo), '("name", ActionGroupNamePropertyInfo), '("sensitive", ActionGroupSensitivePropertyInfo), '("visible", ActionGroupVisiblePropertyInfo)] :: [(Symbol, *)])++data ActionGroupConnectProxySignalInfo+instance SignalInfo ActionGroupConnectProxySignalInfo where+    type HaskellCallbackType ActionGroupConnectProxySignalInfo = ActionGroupConnectProxyCallback+    connectSignal _ = connectActionGroupConnectProxy++data ActionGroupDisconnectProxySignalInfo+instance SignalInfo ActionGroupDisconnectProxySignalInfo where+    type HaskellCallbackType ActionGroupDisconnectProxySignalInfo = ActionGroupDisconnectProxyCallback+    connectSignal _ = connectActionGroupDisconnectProxy++data ActionGroupPostActivateSignalInfo+instance SignalInfo ActionGroupPostActivateSignalInfo where+    type HaskellCallbackType ActionGroupPostActivateSignalInfo = ActionGroupPostActivateCallback+    connectSignal _ = connectActionGroupPostActivate++data ActionGroupPreActivateSignalInfo+instance SignalInfo ActionGroupPreActivateSignalInfo where+    type HaskellCallbackType ActionGroupPreActivateSignalInfo = ActionGroupPreActivateCallback+    connectSignal _ = connectActionGroupPreActivate++type instance SignalList ActionGroup = ActionGroupSignalList+type ActionGroupSignalList = ('[ '("connect-proxy", ActionGroupConnectProxySignalInfo), '("disconnect-proxy", ActionGroupDisconnectProxySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("post-activate", ActionGroupPostActivateSignalInfo), '("pre-activate", ActionGroupPreActivateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ActionGroup::new+-- method type : Constructor+-- 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 "Gtk" "ActionGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_new" gtk_action_group_new :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr ActionGroup)++{-# DEPRECATED actionGroupNew ["(Since version 3.10)"]#-}+actionGroupNew ::+    (MonadIO m) =>+    T.Text ->                               -- name+    m ActionGroup+actionGroupNew name = liftIO $ do+    name' <- textToCString name+    result <- gtk_action_group_new name'+    checkUnexpectedReturnNULL "gtk_action_group_new" result+    result' <- (wrapObject ActionGroup) result+    freeMem name'+    return result'++-- method ActionGroup::add_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_add_action" gtk_action_group_add_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionGroupAddAction ["(Since version 3.10)"]#-}+actionGroupAddAction ::+    (MonadIO m, ActionGroupK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+actionGroupAddAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    gtk_action_group_add_action _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method ActionGroup::add_action_with_accel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator", 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 "gtk_action_group_add_action_with_accel" gtk_action_group_add_action_with_accel :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    CString ->                              -- accelerator : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionGroupAddActionWithAccel ["(Since version 3.10)"]#-}+actionGroupAddActionWithAccel ::+    (MonadIO m, ActionGroupK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    Maybe (T.Text) ->                       -- accelerator+    m ()+actionGroupAddActionWithAccel _obj action accelerator = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    maybeAccelerator <- case accelerator of+        Nothing -> return nullPtr+        Just jAccelerator -> do+            jAccelerator' <- textToCString jAccelerator+            return jAccelerator'+    gtk_action_group_add_action_with_accel _obj' action' maybeAccelerator+    touchManagedPtr _obj+    touchManagedPtr action+    freeMem maybeAccelerator+    return ()++-- method ActionGroup::get_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AccelGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_get_accel_group" gtk_action_group_get_accel_group :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    IO (Ptr AccelGroup)++{-# DEPRECATED actionGroupGetAccelGroup ["(Since version 3.10)"]#-}+actionGroupGetAccelGroup ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m AccelGroup+actionGroupGetAccelGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_group_get_accel_group _obj'+    checkUnexpectedReturnNULL "gtk_action_group_get_accel_group" result+    result' <- (newObject AccelGroup) result+    touchManagedPtr _obj+    return result'++-- method ActionGroup::get_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "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 "Gtk" "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 "Gtk" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_get_action" gtk_action_group_get_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    CString ->                              -- action_name : TBasicType TUTF8+    IO (Ptr Action)++{-# DEPRECATED actionGroupGetAction ["(Since version 3.10)"]#-}+actionGroupGetAction ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    m Action+actionGroupGetAction _obj action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    action_name' <- textToCString action_name+    result <- gtk_action_group_get_action _obj' action_name'+    checkUnexpectedReturnNULL "gtk_action_group_get_action" result+    result' <- (newObject Action) result+    touchManagedPtr _obj+    freeMem action_name'+    return result'++-- method ActionGroup::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_get_name" gtk_action_group_get_name :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    IO CString++{-# DEPRECATED actionGroupGetName ["(Since version 3.10)"]#-}+actionGroupGetName ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m T.Text+actionGroupGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_group_get_name _obj'+    checkUnexpectedReturnNULL "gtk_action_group_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ActionGroup::get_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_get_sensitive" gtk_action_group_get_sensitive :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    IO CInt++{-# DEPRECATED actionGroupGetSensitive ["(Since version 3.10)"]#-}+actionGroupGetSensitive ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m Bool+actionGroupGetSensitive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_group_get_sensitive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ActionGroup::get_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_get_visible" gtk_action_group_get_visible :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    IO CInt++{-# DEPRECATED actionGroupGetVisible ["(Since version 3.10)"]#-}+actionGroupGetVisible ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m Bool+actionGroupGetVisible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_group_get_visible _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ActionGroup::list_actions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "Action")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_list_actions" gtk_action_group_list_actions :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    IO (Ptr (GList (Ptr Action)))++{-# DEPRECATED actionGroupListActions ["(Since version 3.10)"]#-}+actionGroupListActions ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    m [Action]+actionGroupListActions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_action_group_list_actions _obj'+    checkUnexpectedReturnNULL "gtk_action_group_list_actions" result+    result' <- unpackGList result+    result'' <- mapM (newObject Action) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method ActionGroup::remove_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_remove_action" gtk_action_group_remove_action :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    Ptr Action ->                           -- action : TInterface "Gtk" "Action"+    IO ()++{-# DEPRECATED actionGroupRemoveAction ["(Since version 3.10)"]#-}+actionGroupRemoveAction ::+    (MonadIO m, ActionGroupK a, ActionK b) =>+    a ->                                    -- _obj+    b ->                                    -- action+    m ()+actionGroupRemoveAction _obj action = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = unsafeManagedPtrCastPtr action+    gtk_action_group_remove_action _obj' action'+    touchManagedPtr _obj+    touchManagedPtr action+    return ()++-- method ActionGroup::set_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_set_accel_group" gtk_action_group_set_accel_group :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    Ptr AccelGroup ->                       -- accel_group : TInterface "Gtk" "AccelGroup"+    IO ()++{-# DEPRECATED actionGroupSetAccelGroup ["(Since version 3.10)"]#-}+actionGroupSetAccelGroup ::+    (MonadIO m, ActionGroupK a, AccelGroupK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- accel_group+    m ()+actionGroupSetAccelGroup _obj accel_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAccel_group <- case accel_group of+        Nothing -> return nullPtr+        Just jAccel_group -> do+            let jAccel_group' = unsafeManagedPtrCastPtr jAccel_group+            return jAccel_group'+    gtk_action_group_set_accel_group _obj' maybeAccel_group+    touchManagedPtr _obj+    whenJust accel_group touchManagedPtr+    return ()++-- method ActionGroup::set_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", 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 "gtk_action_group_set_sensitive" gtk_action_group_set_sensitive :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    CInt ->                                 -- sensitive : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionGroupSetSensitive ["(Since version 3.10)"]#-}+actionGroupSetSensitive ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- sensitive+    m ()+actionGroupSetSensitive _obj sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitive' = (fromIntegral . fromEnum) sensitive+    gtk_action_group_set_sensitive _obj' sensitive'+    touchManagedPtr _obj+    return ()++-- method ActionGroup::set_translate_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TranslateFunc", 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 = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TranslateFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_action_group_set_translate_func" gtk_action_group_set_translate_func :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    FunPtr TranslateFuncC ->                -- func : TInterface "Gtk" "TranslateFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()++{-# DEPRECATED actionGroupSetTranslateFunc ["(Since version 3.10)"]#-}+actionGroupSetTranslateFunc ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    TranslateFunc ->                        -- func+    m ()+actionGroupSetTranslateFunc _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkTranslateFunc (translateFuncWrapper Nothing func)+    let data_ = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    gtk_action_group_set_translate_func _obj' func' data_ notify+    touchManagedPtr _obj+    return ()++-- method ActionGroup::set_translation_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", 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 "gtk_action_group_set_translation_domain" gtk_action_group_set_translation_domain :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    CString ->                              -- domain : TBasicType TUTF8+    IO ()++{-# DEPRECATED actionGroupSetTranslationDomain ["(Since version 3.10)"]#-}+actionGroupSetTranslationDomain ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- domain+    m ()+actionGroupSetTranslationDomain _obj domain = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDomain <- case domain of+        Nothing -> return nullPtr+        Just jDomain -> do+            jDomain' <- textToCString jDomain+            return jDomain'+    gtk_action_group_set_translation_domain _obj' maybeDomain+    touchManagedPtr _obj+    freeMem maybeDomain+    return ()++-- method ActionGroup::set_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", 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 "gtk_action_group_set_visible" gtk_action_group_set_visible :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    CInt ->                                 -- visible : TBasicType TBoolean+    IO ()++{-# DEPRECATED actionGroupSetVisible ["(Since version 3.10)"]#-}+actionGroupSetVisible ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible+    m ()+actionGroupSetVisible _obj visible = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible' = (fromIntegral . fromEnum) visible+    gtk_action_group_set_visible _obj' visible'+    touchManagedPtr _obj+    return ()++-- method ActionGroup::translate_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ActionGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},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 "gtk_action_group_translate_string" gtk_action_group_translate_string :: +    Ptr ActionGroup ->                      -- _obj : TInterface "Gtk" "ActionGroup"+    CString ->                              -- string : TBasicType TUTF8+    IO CString++{-# DEPRECATED actionGroupTranslateString ["(Since version 3.10)"]#-}+actionGroupTranslateString ::+    (MonadIO m, ActionGroupK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- string+    m T.Text+actionGroupTranslateString _obj string = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    string' <- textToCString string+    result <- gtk_action_group_translate_string _obj' string'+    checkUnexpectedReturnNULL "gtk_action_group_translate_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem string'+    return result'++
+ GI/Gtk/Objects/ActionGroup.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.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)+instance GObject ActionGroup where+class GObject o => ActionGroupK o+instance (GObject o, IsDescendantOf ActionGroup o) => ActionGroupK o+data ActionGroupAccelGroupPropertyInfo+data ActionGroupNamePropertyInfo+data ActionGroupSensitivePropertyInfo+data ActionGroupVisiblePropertyInfo+data ActionGroupConnectProxySignalInfo+data ActionGroupDisconnectProxySignalInfo+data ActionGroupPostActivateSignalInfo+data ActionGroupPreActivateSignalInfo
+ GI/Gtk/Objects/Adjustment.hs view
@@ -0,0 +1,932 @@++{- |+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.Gtk.Objects.Adjustment+    ( ++-- * Exported types+    Adjustment(..)                          ,+    AdjustmentK                             ,+    toAdjustment                            ,+    noAdjustment                            ,+++ -- * Methods+-- ** adjustmentChanged+    adjustmentChanged                       ,+++-- ** adjustmentClampPage+    adjustmentClampPage                     ,+++-- ** adjustmentConfigure+    adjustmentConfigure                     ,+++-- ** adjustmentGetLower+    adjustmentGetLower                      ,+++-- ** adjustmentGetMinimumIncrement+    adjustmentGetMinimumIncrement           ,+++-- ** adjustmentGetPageIncrement+    adjustmentGetPageIncrement              ,+++-- ** adjustmentGetPageSize+    adjustmentGetPageSize                   ,+++-- ** adjustmentGetStepIncrement+    adjustmentGetStepIncrement              ,+++-- ** adjustmentGetUpper+    adjustmentGetUpper                      ,+++-- ** adjustmentGetValue+    adjustmentGetValue                      ,+++-- ** adjustmentNew+    adjustmentNew                           ,+++-- ** adjustmentSetLower+    adjustmentSetLower                      ,+++-- ** adjustmentSetPageIncrement+    adjustmentSetPageIncrement              ,+++-- ** adjustmentSetPageSize+    adjustmentSetPageSize                   ,+++-- ** adjustmentSetStepIncrement+    adjustmentSetStepIncrement              ,+++-- ** adjustmentSetUpper+    adjustmentSetUpper                      ,+++-- ** adjustmentSetValue+    adjustmentSetValue                      ,+++-- ** adjustmentValueChanged+    adjustmentValueChanged                  ,+++++ -- * Properties+-- ** Lower+    AdjustmentLowerPropertyInfo             ,+    constructAdjustmentLower                ,+    getAdjustmentLower                      ,+    setAdjustmentLower                      ,+++-- ** PageIncrement+    AdjustmentPageIncrementPropertyInfo     ,+    constructAdjustmentPageIncrement        ,+    getAdjustmentPageIncrement              ,+    setAdjustmentPageIncrement              ,+++-- ** PageSize+    AdjustmentPageSizePropertyInfo          ,+    constructAdjustmentPageSize             ,+    getAdjustmentPageSize                   ,+    setAdjustmentPageSize                   ,+++-- ** StepIncrement+    AdjustmentStepIncrementPropertyInfo     ,+    constructAdjustmentStepIncrement        ,+    getAdjustmentStepIncrement              ,+    setAdjustmentStepIncrement              ,+++-- ** Upper+    AdjustmentUpperPropertyInfo             ,+    constructAdjustmentUpper                ,+    getAdjustmentUpper                      ,+    setAdjustmentUpper                      ,+++-- ** Value+    AdjustmentValuePropertyInfo             ,+    constructAdjustmentValue                ,+    getAdjustmentValue                      ,+    setAdjustmentValue                      ,+++++ -- * Signals+-- ** Changed+    AdjustmentChangedCallback               ,+    AdjustmentChangedCallbackC              ,+    AdjustmentChangedSignalInfo             ,+    adjustmentChangedCallbackWrapper        ,+    adjustmentChangedClosure                ,+    afterAdjustmentChanged                  ,+    mkAdjustmentChangedCallback             ,+    noAdjustmentChangedCallback             ,+    onAdjustmentChanged                     ,+++-- ** ValueChanged+    AdjustmentValueChangedCallback          ,+    AdjustmentValueChangedCallbackC         ,+    AdjustmentValueChangedSignalInfo        ,+    adjustmentValueChangedCallbackWrapper   ,+    adjustmentValueChangedClosure           ,+    afterAdjustmentValueChanged             ,+    mkAdjustmentValueChangedCallback        ,+    noAdjustmentValueChangedCallback        ,+    onAdjustmentValueChanged                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype Adjustment = Adjustment (ForeignPtr Adjustment)+foreign import ccall "gtk_adjustment_get_type"+    c_gtk_adjustment_get_type :: IO GType++type instance ParentTypes Adjustment = AdjustmentParentTypes+type AdjustmentParentTypes = '[GObject.Object]++instance GObject Adjustment where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_adjustment_get_type+    ++class GObject o => AdjustmentK o+instance (GObject o, IsDescendantOf Adjustment o) => AdjustmentK o++toAdjustment :: AdjustmentK o => o -> IO Adjustment+toAdjustment = unsafeCastTo Adjustment++noAdjustment :: Maybe Adjustment+noAdjustment = Nothing++-- signal Adjustment::changed+type AdjustmentChangedCallback =+    IO ()++noAdjustmentChangedCallback :: Maybe AdjustmentChangedCallback+noAdjustmentChangedCallback = Nothing++type AdjustmentChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAdjustmentChangedCallback :: AdjustmentChangedCallbackC -> IO (FunPtr AdjustmentChangedCallbackC)++adjustmentChangedClosure :: AdjustmentChangedCallback -> IO Closure+adjustmentChangedClosure cb = newCClosure =<< mkAdjustmentChangedCallback wrapped+    where wrapped = adjustmentChangedCallbackWrapper cb++adjustmentChangedCallbackWrapper ::+    AdjustmentChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+adjustmentChangedCallbackWrapper _cb _ _ = do+    _cb ++onAdjustmentChanged :: (GObject a, MonadIO m) => a -> AdjustmentChangedCallback -> m SignalHandlerId+onAdjustmentChanged obj cb = liftIO $ connectAdjustmentChanged obj cb SignalConnectBefore+afterAdjustmentChanged :: (GObject a, MonadIO m) => a -> AdjustmentChangedCallback -> m SignalHandlerId+afterAdjustmentChanged obj cb = connectAdjustmentChanged obj cb SignalConnectAfter++connectAdjustmentChanged :: (GObject a, MonadIO m) =>+                            a -> AdjustmentChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectAdjustmentChanged obj cb after = liftIO $ do+    cb' <- mkAdjustmentChangedCallback (adjustmentChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal Adjustment::value-changed+type AdjustmentValueChangedCallback =+    IO ()++noAdjustmentValueChangedCallback :: Maybe AdjustmentValueChangedCallback+noAdjustmentValueChangedCallback = Nothing++type AdjustmentValueChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAdjustmentValueChangedCallback :: AdjustmentValueChangedCallbackC -> IO (FunPtr AdjustmentValueChangedCallbackC)++adjustmentValueChangedClosure :: AdjustmentValueChangedCallback -> IO Closure+adjustmentValueChangedClosure cb = newCClosure =<< mkAdjustmentValueChangedCallback wrapped+    where wrapped = adjustmentValueChangedCallbackWrapper cb++adjustmentValueChangedCallbackWrapper ::+    AdjustmentValueChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+adjustmentValueChangedCallbackWrapper _cb _ _ = do+    _cb ++onAdjustmentValueChanged :: (GObject a, MonadIO m) => a -> AdjustmentValueChangedCallback -> m SignalHandlerId+onAdjustmentValueChanged obj cb = liftIO $ connectAdjustmentValueChanged obj cb SignalConnectBefore+afterAdjustmentValueChanged :: (GObject a, MonadIO m) => a -> AdjustmentValueChangedCallback -> m SignalHandlerId+afterAdjustmentValueChanged obj cb = connectAdjustmentValueChanged obj cb SignalConnectAfter++connectAdjustmentValueChanged :: (GObject a, MonadIO m) =>+                                 a -> AdjustmentValueChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectAdjustmentValueChanged obj cb after = liftIO $ do+    cb' <- mkAdjustmentValueChangedCallback (adjustmentValueChangedCallbackWrapper cb)+    connectSignalFunPtr obj "value-changed" cb' after++-- VVV Prop "lower"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentLower :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentLower obj = liftIO $ getObjectPropertyDouble obj "lower"++setAdjustmentLower :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentLower obj val = liftIO $ setObjectPropertyDouble obj "lower" val++constructAdjustmentLower :: Double -> IO ([Char], GValue)+constructAdjustmentLower val = constructObjectPropertyDouble "lower" val++data AdjustmentLowerPropertyInfo+instance AttrInfo AdjustmentLowerPropertyInfo where+    type AttrAllowedOps AdjustmentLowerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentLowerPropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentLowerPropertyInfo = AdjustmentK+    type AttrGetType AdjustmentLowerPropertyInfo = Double+    type AttrLabel AdjustmentLowerPropertyInfo = "Adjustment::lower"+    attrGet _ = getAdjustmentLower+    attrSet _ = setAdjustmentLower+    attrConstruct _ = constructAdjustmentLower++-- VVV Prop "page-increment"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentPageIncrement :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentPageIncrement obj = liftIO $ getObjectPropertyDouble obj "page-increment"++setAdjustmentPageIncrement :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentPageIncrement obj val = liftIO $ setObjectPropertyDouble obj "page-increment" val++constructAdjustmentPageIncrement :: Double -> IO ([Char], GValue)+constructAdjustmentPageIncrement val = constructObjectPropertyDouble "page-increment" val++data AdjustmentPageIncrementPropertyInfo+instance AttrInfo AdjustmentPageIncrementPropertyInfo where+    type AttrAllowedOps AdjustmentPageIncrementPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentPageIncrementPropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentPageIncrementPropertyInfo = AdjustmentK+    type AttrGetType AdjustmentPageIncrementPropertyInfo = Double+    type AttrLabel AdjustmentPageIncrementPropertyInfo = "Adjustment::page-increment"+    attrGet _ = getAdjustmentPageIncrement+    attrSet _ = setAdjustmentPageIncrement+    attrConstruct _ = constructAdjustmentPageIncrement++-- VVV Prop "page-size"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentPageSize :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentPageSize obj = liftIO $ getObjectPropertyDouble obj "page-size"++setAdjustmentPageSize :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentPageSize obj val = liftIO $ setObjectPropertyDouble obj "page-size" val++constructAdjustmentPageSize :: Double -> IO ([Char], GValue)+constructAdjustmentPageSize val = constructObjectPropertyDouble "page-size" val++data AdjustmentPageSizePropertyInfo+instance AttrInfo AdjustmentPageSizePropertyInfo where+    type AttrAllowedOps AdjustmentPageSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentPageSizePropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentPageSizePropertyInfo = AdjustmentK+    type AttrGetType AdjustmentPageSizePropertyInfo = Double+    type AttrLabel AdjustmentPageSizePropertyInfo = "Adjustment::page-size"+    attrGet _ = getAdjustmentPageSize+    attrSet _ = setAdjustmentPageSize+    attrConstruct _ = constructAdjustmentPageSize++-- VVV Prop "step-increment"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentStepIncrement :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentStepIncrement obj = liftIO $ getObjectPropertyDouble obj "step-increment"++setAdjustmentStepIncrement :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentStepIncrement obj val = liftIO $ setObjectPropertyDouble obj "step-increment" val++constructAdjustmentStepIncrement :: Double -> IO ([Char], GValue)+constructAdjustmentStepIncrement val = constructObjectPropertyDouble "step-increment" val++data AdjustmentStepIncrementPropertyInfo+instance AttrInfo AdjustmentStepIncrementPropertyInfo where+    type AttrAllowedOps AdjustmentStepIncrementPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentStepIncrementPropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentStepIncrementPropertyInfo = AdjustmentK+    type AttrGetType AdjustmentStepIncrementPropertyInfo = Double+    type AttrLabel AdjustmentStepIncrementPropertyInfo = "Adjustment::step-increment"+    attrGet _ = getAdjustmentStepIncrement+    attrSet _ = setAdjustmentStepIncrement+    attrConstruct _ = constructAdjustmentStepIncrement++-- VVV Prop "upper"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentUpper :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentUpper obj = liftIO $ getObjectPropertyDouble obj "upper"++setAdjustmentUpper :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentUpper obj val = liftIO $ setObjectPropertyDouble obj "upper" val++constructAdjustmentUpper :: Double -> IO ([Char], GValue)+constructAdjustmentUpper val = constructObjectPropertyDouble "upper" val++data AdjustmentUpperPropertyInfo+instance AttrInfo AdjustmentUpperPropertyInfo where+    type AttrAllowedOps AdjustmentUpperPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentUpperPropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentUpperPropertyInfo = AdjustmentK+    type AttrGetType AdjustmentUpperPropertyInfo = Double+    type AttrLabel AdjustmentUpperPropertyInfo = "Adjustment::upper"+    attrGet _ = getAdjustmentUpper+    attrSet _ = setAdjustmentUpper+    attrConstruct _ = constructAdjustmentUpper++-- VVV Prop "value"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getAdjustmentValue :: (MonadIO m, AdjustmentK o) => o -> m Double+getAdjustmentValue obj = liftIO $ getObjectPropertyDouble obj "value"++setAdjustmentValue :: (MonadIO m, AdjustmentK o) => o -> Double -> m ()+setAdjustmentValue obj val = liftIO $ setObjectPropertyDouble obj "value" val++constructAdjustmentValue :: Double -> IO ([Char], GValue)+constructAdjustmentValue val = constructObjectPropertyDouble "value" val++data AdjustmentValuePropertyInfo+instance AttrInfo AdjustmentValuePropertyInfo where+    type AttrAllowedOps AdjustmentValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AdjustmentValuePropertyInfo = (~) Double+    type AttrBaseTypeConstraint AdjustmentValuePropertyInfo = AdjustmentK+    type AttrGetType AdjustmentValuePropertyInfo = Double+    type AttrLabel AdjustmentValuePropertyInfo = "Adjustment::value"+    attrGet _ = getAdjustmentValue+    attrSet _ = setAdjustmentValue+    attrConstruct _ = constructAdjustmentValue++type instance AttributeList Adjustment = AdjustmentAttributeList+type AdjustmentAttributeList = ('[ '("lower", AdjustmentLowerPropertyInfo), '("page-increment", AdjustmentPageIncrementPropertyInfo), '("page-size", AdjustmentPageSizePropertyInfo), '("step-increment", AdjustmentStepIncrementPropertyInfo), '("upper", AdjustmentUpperPropertyInfo), '("value", AdjustmentValuePropertyInfo)] :: [(Symbol, *)])++data AdjustmentChangedSignalInfo+instance SignalInfo AdjustmentChangedSignalInfo where+    type HaskellCallbackType AdjustmentChangedSignalInfo = AdjustmentChangedCallback+    connectSignal _ = connectAdjustmentChanged++data AdjustmentValueChangedSignalInfo+instance SignalInfo AdjustmentValueChangedSignalInfo where+    type HaskellCallbackType AdjustmentValueChangedSignalInfo = AdjustmentValueChangedCallback+    connectSignal _ = connectAdjustmentValueChanged++type instance SignalList Adjustment = AdjustmentSignalList+type AdjustmentSignalList = ('[ '("changed", AdjustmentChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("value-changed", AdjustmentValueChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Adjustment::new+-- method type : Constructor+-- Args : [Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_new" gtk_adjustment_new :: +    CDouble ->                              -- value : TBasicType TDouble+    CDouble ->                              -- lower : TBasicType TDouble+    CDouble ->                              -- upper : TBasicType TDouble+    CDouble ->                              -- step_increment : TBasicType TDouble+    CDouble ->                              -- page_increment : TBasicType TDouble+    CDouble ->                              -- page_size : TBasicType TDouble+    IO (Ptr Adjustment)+++adjustmentNew ::+    (MonadIO m) =>+    Double ->                               -- value+    Double ->                               -- lower+    Double ->                               -- upper+    Double ->                               -- step_increment+    Double ->                               -- page_increment+    Double ->                               -- page_size+    m Adjustment+adjustmentNew value lower upper step_increment page_increment page_size = liftIO $ do+    let value' = realToFrac value+    let lower' = realToFrac lower+    let upper' = realToFrac upper+    let step_increment' = realToFrac step_increment+    let page_increment' = realToFrac page_increment+    let page_size' = realToFrac page_size+    result <- gtk_adjustment_new value' lower' upper' step_increment' page_increment' page_size'+    checkUnexpectedReturnNULL "gtk_adjustment_new" result+    result' <- (newObject Adjustment) result+    return result'++-- method Adjustment::changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_changed" gtk_adjustment_changed :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO ()++{-# DEPRECATED adjustmentChanged ["(Since version 3.18)","GTK+ emits #GtkAdjustment::changed itself whenever any","   of the properties (other than value) change"]#-}+adjustmentChanged ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m ()+adjustmentChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_adjustment_changed _obj'+    touchManagedPtr _obj+    return ()++-- method Adjustment::clamp_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_clamp_page" gtk_adjustment_clamp_page :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- lower : TBasicType TDouble+    CDouble ->                              -- upper : TBasicType TDouble+    IO ()+++adjustmentClampPage ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- lower+    Double ->                               -- upper+    m ()+adjustmentClampPage _obj lower upper = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let lower' = realToFrac lower+    let upper' = realToFrac upper+    gtk_adjustment_clamp_page _obj' lower' upper'+    touchManagedPtr _obj+    return ()++-- method Adjustment::configure+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", 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},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", 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},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_configure" gtk_adjustment_configure :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- value : TBasicType TDouble+    CDouble ->                              -- lower : TBasicType TDouble+    CDouble ->                              -- upper : TBasicType TDouble+    CDouble ->                              -- step_increment : TBasicType TDouble+    CDouble ->                              -- page_increment : TBasicType TDouble+    CDouble ->                              -- page_size : TBasicType TDouble+    IO ()+++adjustmentConfigure ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    Double ->                               -- lower+    Double ->                               -- upper+    Double ->                               -- step_increment+    Double ->                               -- page_increment+    Double ->                               -- page_size+    m ()+adjustmentConfigure _obj value lower upper step_increment page_increment page_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    let lower' = realToFrac lower+    let upper' = realToFrac upper+    let step_increment' = realToFrac step_increment+    let page_increment' = realToFrac page_increment+    let page_size' = realToFrac page_size+    gtk_adjustment_configure _obj' value' lower' upper' step_increment' page_increment' page_size'+    touchManagedPtr _obj+    return ()++-- method Adjustment::get_lower+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_lower" gtk_adjustment_get_lower :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetLower ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetLower _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_lower _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_minimum_increment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_minimum_increment" gtk_adjustment_get_minimum_increment :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetMinimumIncrement ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetMinimumIncrement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_minimum_increment _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_page_increment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_page_increment" gtk_adjustment_get_page_increment :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetPageIncrement ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetPageIncrement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_page_increment _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_page_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_page_size" gtk_adjustment_get_page_size :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetPageSize ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetPageSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_page_size _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_step_increment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_step_increment" gtk_adjustment_get_step_increment :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetStepIncrement ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetStepIncrement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_step_increment _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_upper+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_upper" gtk_adjustment_get_upper :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetUpper ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetUpper _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_upper _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_get_value" gtk_adjustment_get_value :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO CDouble+++adjustmentGetValue ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m Double+adjustmentGetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_adjustment_get_value _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Adjustment::set_lower+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lower", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_lower" gtk_adjustment_set_lower :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- lower : TBasicType TDouble+    IO ()+++adjustmentSetLower ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- lower+    m ()+adjustmentSetLower _obj lower = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let lower' = realToFrac lower+    gtk_adjustment_set_lower _obj' lower'+    touchManagedPtr _obj+    return ()++-- method Adjustment::set_page_increment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_page_increment" gtk_adjustment_set_page_increment :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- page_increment : TBasicType TDouble+    IO ()+++adjustmentSetPageIncrement ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- page_increment+    m ()+adjustmentSetPageIncrement _obj page_increment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page_increment' = realToFrac page_increment+    gtk_adjustment_set_page_increment _obj' page_increment'+    touchManagedPtr _obj+    return ()++-- method Adjustment::set_page_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_size", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_page_size" gtk_adjustment_set_page_size :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- page_size : TBasicType TDouble+    IO ()+++adjustmentSetPageSize ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- page_size+    m ()+adjustmentSetPageSize _obj page_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page_size' = realToFrac page_size+    gtk_adjustment_set_page_size _obj' page_size'+    touchManagedPtr _obj+    return ()++-- method Adjustment::set_step_increment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step_increment", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_step_increment" gtk_adjustment_set_step_increment :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- step_increment : TBasicType TDouble+    IO ()+++adjustmentSetStepIncrement ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- step_increment+    m ()+adjustmentSetStepIncrement _obj step_increment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let step_increment' = realToFrac step_increment+    gtk_adjustment_set_step_increment _obj' step_increment'+    touchManagedPtr _obj+    return ()++-- method Adjustment::set_upper+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "upper", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_upper" gtk_adjustment_set_upper :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- upper : TBasicType TDouble+    IO ()+++adjustmentSetUpper ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- upper+    m ()+adjustmentSetUpper _obj upper = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let upper' = realToFrac upper+    gtk_adjustment_set_upper _obj' upper'+    touchManagedPtr _obj+    return ()++-- method Adjustment::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", 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 "Gtk" "Adjustment", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_set_value" gtk_adjustment_set_value :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++adjustmentSetValue ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    m ()+adjustmentSetValue _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    gtk_adjustment_set_value _obj' value'+    touchManagedPtr _obj+    return ()++-- method Adjustment::value_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_adjustment_value_changed" gtk_adjustment_value_changed :: +    Ptr Adjustment ->                       -- _obj : TInterface "Gtk" "Adjustment"+    IO ()++{-# DEPRECATED adjustmentValueChanged ["(Since version 3.18)","GTK+ emits #GtkAdjustment::value-changed itself whenever","   the value changes"]#-}+adjustmentValueChanged ::+    (MonadIO m, AdjustmentK a) =>+    a ->                                    -- _obj+    m ()+adjustmentValueChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_adjustment_value_changed _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Adjustment.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.Adjustment where++import Prelude ()+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 Adjustment = Adjustment (ForeignPtr Adjustment)+instance GObject Adjustment where+class GObject o => AdjustmentK o+instance (GObject o, IsDescendantOf Adjustment o) => AdjustmentK o+data AdjustmentLowerPropertyInfo+data AdjustmentPageIncrementPropertyInfo+data AdjustmentPageSizePropertyInfo+data AdjustmentStepIncrementPropertyInfo+data AdjustmentUpperPropertyInfo+data AdjustmentValuePropertyInfo+data AdjustmentChangedSignalInfo+data AdjustmentValueChangedSignalInfo
+ GI/Gtk/Objects/Alignment.hs view
@@ -0,0 +1,471 @@++{- |+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.Gtk.Objects.Alignment+    ( ++-- * Exported types+    Alignment(..)                           ,+    AlignmentK                              ,+    toAlignment                             ,+    noAlignment                             ,+++ -- * Methods+-- ** alignmentGetPadding+    alignmentGetPadding                     ,+++-- ** alignmentNew+    alignmentNew                            ,+++-- ** alignmentSet+    alignmentSet                            ,+++-- ** alignmentSetPadding+    alignmentSetPadding                     ,+++++ -- * Properties+-- ** BottomPadding+    AlignmentBottomPaddingPropertyInfo      ,+    constructAlignmentBottomPadding         ,+    getAlignmentBottomPadding               ,+    setAlignmentBottomPadding               ,+++-- ** LeftPadding+    AlignmentLeftPaddingPropertyInfo        ,+    constructAlignmentLeftPadding           ,+    getAlignmentLeftPadding                 ,+    setAlignmentLeftPadding                 ,+++-- ** RightPadding+    AlignmentRightPaddingPropertyInfo       ,+    constructAlignmentRightPadding          ,+    getAlignmentRightPadding                ,+    setAlignmentRightPadding                ,+++-- ** TopPadding+    AlignmentTopPaddingPropertyInfo         ,+    constructAlignmentTopPadding            ,+    getAlignmentTopPadding                  ,+    setAlignmentTopPadding                  ,+++-- ** Xalign+    AlignmentXalignPropertyInfo             ,+    constructAlignmentXalign                ,+    getAlignmentXalign                      ,+    setAlignmentXalign                      ,+++-- ** Xscale+    AlignmentXscalePropertyInfo             ,+    constructAlignmentXscale                ,+    getAlignmentXscale                      ,+    setAlignmentXscale                      ,+++-- ** Yalign+    AlignmentYalignPropertyInfo             ,+    constructAlignmentYalign                ,+    getAlignmentYalign                      ,+    setAlignmentYalign                      ,+++-- ** Yscale+    AlignmentYscalePropertyInfo             ,+    constructAlignmentYscale                ,+    getAlignmentYscale                      ,+    setAlignmentYscale                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Alignment = Alignment (ForeignPtr Alignment)+foreign import ccall "gtk_alignment_get_type"+    c_gtk_alignment_get_type :: IO GType++type instance ParentTypes Alignment = AlignmentParentTypes+type AlignmentParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Alignment where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_alignment_get_type+    ++class GObject o => AlignmentK o+instance (GObject o, IsDescendantOf Alignment o) => AlignmentK o++toAlignment :: AlignmentK o => o -> IO Alignment+toAlignment = unsafeCastTo Alignment++noAlignment :: Maybe Alignment+noAlignment = Nothing++-- VVV Prop "bottom-padding"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentBottomPadding :: (MonadIO m, AlignmentK o) => o -> m Word32+getAlignmentBottomPadding obj = liftIO $ getObjectPropertyCUInt obj "bottom-padding"++setAlignmentBottomPadding :: (MonadIO m, AlignmentK o) => o -> Word32 -> m ()+setAlignmentBottomPadding obj val = liftIO $ setObjectPropertyCUInt obj "bottom-padding" val++constructAlignmentBottomPadding :: Word32 -> IO ([Char], GValue)+constructAlignmentBottomPadding val = constructObjectPropertyCUInt "bottom-padding" val++data AlignmentBottomPaddingPropertyInfo+instance AttrInfo AlignmentBottomPaddingPropertyInfo where+    type AttrAllowedOps AlignmentBottomPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentBottomPaddingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint AlignmentBottomPaddingPropertyInfo = AlignmentK+    type AttrGetType AlignmentBottomPaddingPropertyInfo = Word32+    type AttrLabel AlignmentBottomPaddingPropertyInfo = "Alignment::bottom-padding"+    attrGet _ = getAlignmentBottomPadding+    attrSet _ = setAlignmentBottomPadding+    attrConstruct _ = constructAlignmentBottomPadding++-- VVV Prop "left-padding"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentLeftPadding :: (MonadIO m, AlignmentK o) => o -> m Word32+getAlignmentLeftPadding obj = liftIO $ getObjectPropertyCUInt obj "left-padding"++setAlignmentLeftPadding :: (MonadIO m, AlignmentK o) => o -> Word32 -> m ()+setAlignmentLeftPadding obj val = liftIO $ setObjectPropertyCUInt obj "left-padding" val++constructAlignmentLeftPadding :: Word32 -> IO ([Char], GValue)+constructAlignmentLeftPadding val = constructObjectPropertyCUInt "left-padding" val++data AlignmentLeftPaddingPropertyInfo+instance AttrInfo AlignmentLeftPaddingPropertyInfo where+    type AttrAllowedOps AlignmentLeftPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentLeftPaddingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint AlignmentLeftPaddingPropertyInfo = AlignmentK+    type AttrGetType AlignmentLeftPaddingPropertyInfo = Word32+    type AttrLabel AlignmentLeftPaddingPropertyInfo = "Alignment::left-padding"+    attrGet _ = getAlignmentLeftPadding+    attrSet _ = setAlignmentLeftPadding+    attrConstruct _ = constructAlignmentLeftPadding++-- VVV Prop "right-padding"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentRightPadding :: (MonadIO m, AlignmentK o) => o -> m Word32+getAlignmentRightPadding obj = liftIO $ getObjectPropertyCUInt obj "right-padding"++setAlignmentRightPadding :: (MonadIO m, AlignmentK o) => o -> Word32 -> m ()+setAlignmentRightPadding obj val = liftIO $ setObjectPropertyCUInt obj "right-padding" val++constructAlignmentRightPadding :: Word32 -> IO ([Char], GValue)+constructAlignmentRightPadding val = constructObjectPropertyCUInt "right-padding" val++data AlignmentRightPaddingPropertyInfo+instance AttrInfo AlignmentRightPaddingPropertyInfo where+    type AttrAllowedOps AlignmentRightPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentRightPaddingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint AlignmentRightPaddingPropertyInfo = AlignmentK+    type AttrGetType AlignmentRightPaddingPropertyInfo = Word32+    type AttrLabel AlignmentRightPaddingPropertyInfo = "Alignment::right-padding"+    attrGet _ = getAlignmentRightPadding+    attrSet _ = setAlignmentRightPadding+    attrConstruct _ = constructAlignmentRightPadding++-- VVV Prop "top-padding"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentTopPadding :: (MonadIO m, AlignmentK o) => o -> m Word32+getAlignmentTopPadding obj = liftIO $ getObjectPropertyCUInt obj "top-padding"++setAlignmentTopPadding :: (MonadIO m, AlignmentK o) => o -> Word32 -> m ()+setAlignmentTopPadding obj val = liftIO $ setObjectPropertyCUInt obj "top-padding" val++constructAlignmentTopPadding :: Word32 -> IO ([Char], GValue)+constructAlignmentTopPadding val = constructObjectPropertyCUInt "top-padding" val++data AlignmentTopPaddingPropertyInfo+instance AttrInfo AlignmentTopPaddingPropertyInfo where+    type AttrAllowedOps AlignmentTopPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentTopPaddingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint AlignmentTopPaddingPropertyInfo = AlignmentK+    type AttrGetType AlignmentTopPaddingPropertyInfo = Word32+    type AttrLabel AlignmentTopPaddingPropertyInfo = "Alignment::top-padding"+    attrGet _ = getAlignmentTopPadding+    attrSet _ = setAlignmentTopPadding+    attrConstruct _ = constructAlignmentTopPadding++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentXalign :: (MonadIO m, AlignmentK o) => o -> m Float+getAlignmentXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setAlignmentXalign :: (MonadIO m, AlignmentK o) => o -> Float -> m ()+setAlignmentXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructAlignmentXalign :: Float -> IO ([Char], GValue)+constructAlignmentXalign val = constructObjectPropertyFloat "xalign" val++data AlignmentXalignPropertyInfo+instance AttrInfo AlignmentXalignPropertyInfo where+    type AttrAllowedOps AlignmentXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint AlignmentXalignPropertyInfo = AlignmentK+    type AttrGetType AlignmentXalignPropertyInfo = Float+    type AttrLabel AlignmentXalignPropertyInfo = "Alignment::xalign"+    attrGet _ = getAlignmentXalign+    attrSet _ = setAlignmentXalign+    attrConstruct _ = constructAlignmentXalign++-- VVV Prop "xscale"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentXscale :: (MonadIO m, AlignmentK o) => o -> m Float+getAlignmentXscale obj = liftIO $ getObjectPropertyFloat obj "xscale"++setAlignmentXscale :: (MonadIO m, AlignmentK o) => o -> Float -> m ()+setAlignmentXscale obj val = liftIO $ setObjectPropertyFloat obj "xscale" val++constructAlignmentXscale :: Float -> IO ([Char], GValue)+constructAlignmentXscale val = constructObjectPropertyFloat "xscale" val++data AlignmentXscalePropertyInfo+instance AttrInfo AlignmentXscalePropertyInfo where+    type AttrAllowedOps AlignmentXscalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentXscalePropertyInfo = (~) Float+    type AttrBaseTypeConstraint AlignmentXscalePropertyInfo = AlignmentK+    type AttrGetType AlignmentXscalePropertyInfo = Float+    type AttrLabel AlignmentXscalePropertyInfo = "Alignment::xscale"+    attrGet _ = getAlignmentXscale+    attrSet _ = setAlignmentXscale+    attrConstruct _ = constructAlignmentXscale++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentYalign :: (MonadIO m, AlignmentK o) => o -> m Float+getAlignmentYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setAlignmentYalign :: (MonadIO m, AlignmentK o) => o -> Float -> m ()+setAlignmentYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructAlignmentYalign :: Float -> IO ([Char], GValue)+constructAlignmentYalign val = constructObjectPropertyFloat "yalign" val++data AlignmentYalignPropertyInfo+instance AttrInfo AlignmentYalignPropertyInfo where+    type AttrAllowedOps AlignmentYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint AlignmentYalignPropertyInfo = AlignmentK+    type AttrGetType AlignmentYalignPropertyInfo = Float+    type AttrLabel AlignmentYalignPropertyInfo = "Alignment::yalign"+    attrGet _ = getAlignmentYalign+    attrSet _ = setAlignmentYalign+    attrConstruct _ = constructAlignmentYalign++-- VVV Prop "yscale"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAlignmentYscale :: (MonadIO m, AlignmentK o) => o -> m Float+getAlignmentYscale obj = liftIO $ getObjectPropertyFloat obj "yscale"++setAlignmentYscale :: (MonadIO m, AlignmentK o) => o -> Float -> m ()+setAlignmentYscale obj val = liftIO $ setObjectPropertyFloat obj "yscale" val++constructAlignmentYscale :: Float -> IO ([Char], GValue)+constructAlignmentYscale val = constructObjectPropertyFloat "yscale" val++data AlignmentYscalePropertyInfo+instance AttrInfo AlignmentYscalePropertyInfo where+    type AttrAllowedOps AlignmentYscalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AlignmentYscalePropertyInfo = (~) Float+    type AttrBaseTypeConstraint AlignmentYscalePropertyInfo = AlignmentK+    type AttrGetType AlignmentYscalePropertyInfo = Float+    type AttrLabel AlignmentYscalePropertyInfo = "Alignment::yscale"+    attrGet _ = getAlignmentYscale+    attrSet _ = setAlignmentYscale+    attrConstruct _ = constructAlignmentYscale++type instance AttributeList Alignment = AlignmentAttributeList+type AlignmentAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("bottom-padding", AlignmentBottomPaddingPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("left-padding", AlignmentLeftPaddingPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("right-padding", AlignmentRightPaddingPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("top-padding", AlignmentTopPaddingPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", AlignmentXalignPropertyInfo), '("xscale", AlignmentXscalePropertyInfo), '("yalign", AlignmentYalignPropertyInfo), '("yscale", AlignmentYscalePropertyInfo)] :: [(Symbol, *)])++type instance SignalList Alignment = AlignmentSignalList+type AlignmentSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Alignment::new+-- method type : Constructor+-- Args : [Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Alignment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_alignment_new" gtk_alignment_new :: +    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    CFloat ->                               -- xscale : TBasicType TFloat+    CFloat ->                               -- yscale : TBasicType TFloat+    IO (Ptr Alignment)++{-# DEPRECATED alignmentNew ["(Since version 3.14)","Use #GtkWidget alignment and margin properties"]#-}+alignmentNew ::+    (MonadIO m) =>+    Float ->                                -- xalign+    Float ->                                -- yalign+    Float ->                                -- xscale+    Float ->                                -- yscale+    m Alignment+alignmentNew xalign yalign xscale yscale = liftIO $ do+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    let xscale' = realToFrac xscale+    let yscale' = realToFrac yscale+    result <- gtk_alignment_new xalign' yalign' xscale' yscale'+    checkUnexpectedReturnNULL "gtk_alignment_new" result+    result' <- (newObject Alignment) result+    return result'++-- method Alignment::get_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_top", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "padding_bottom", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "padding_left", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "padding_right", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_alignment_get_padding" gtk_alignment_get_padding :: +    Ptr Alignment ->                        -- _obj : TInterface "Gtk" "Alignment"+    Ptr Word32 ->                           -- padding_top : TBasicType TUInt32+    Ptr Word32 ->                           -- padding_bottom : TBasicType TUInt32+    Ptr Word32 ->                           -- padding_left : TBasicType TUInt32+    Ptr Word32 ->                           -- padding_right : TBasicType TUInt32+    IO ()++{-# DEPRECATED alignmentGetPadding ["(Since version 3.14)","Use #GtkWidget alignment and margin properties"]#-}+alignmentGetPadding ::+    (MonadIO m, AlignmentK a) =>+    a ->                                    -- _obj+    m (Word32,Word32,Word32,Word32)+alignmentGetPadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    padding_top <- allocMem :: IO (Ptr Word32)+    padding_bottom <- allocMem :: IO (Ptr Word32)+    padding_left <- allocMem :: IO (Ptr Word32)+    padding_right <- allocMem :: IO (Ptr Word32)+    gtk_alignment_get_padding _obj' padding_top padding_bottom padding_left padding_right+    padding_top' <- peek padding_top+    padding_bottom' <- peek padding_bottom+    padding_left' <- peek padding_left+    padding_right' <- peek padding_right+    touchManagedPtr _obj+    freeMem padding_top+    freeMem padding_bottom+    freeMem padding_left+    freeMem padding_right+    return (padding_top', padding_bottom', padding_left', padding_right')++-- method Alignment::set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yscale", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_alignment_set" gtk_alignment_set :: +    Ptr Alignment ->                        -- _obj : TInterface "Gtk" "Alignment"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    CFloat ->                               -- xscale : TBasicType TFloat+    CFloat ->                               -- yscale : TBasicType TFloat+    IO ()++{-# DEPRECATED alignmentSet ["(Since version 3.14)","Use #GtkWidget alignment and margin properties"]#-}+alignmentSet ::+    (MonadIO m, AlignmentK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    Float ->                                -- xscale+    Float ->                                -- yscale+    m ()+alignmentSet _obj xalign yalign xscale yscale = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    let xscale' = realToFrac xscale+    let yscale' = realToFrac yscale+    gtk_alignment_set _obj' xalign' yalign' xscale' yscale'+    touchManagedPtr _obj+    return ()++-- method Alignment::set_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_top", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_bottom", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_left", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_right", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Alignment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_top", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_bottom", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_left", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding_right", 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 "gtk_alignment_set_padding" gtk_alignment_set_padding :: +    Ptr Alignment ->                        -- _obj : TInterface "Gtk" "Alignment"+    Word32 ->                               -- padding_top : TBasicType TUInt32+    Word32 ->                               -- padding_bottom : TBasicType TUInt32+    Word32 ->                               -- padding_left : TBasicType TUInt32+    Word32 ->                               -- padding_right : TBasicType TUInt32+    IO ()++{-# DEPRECATED alignmentSetPadding ["(Since version 3.14)","Use #GtkWidget alignment and margin properties"]#-}+alignmentSetPadding ::+    (MonadIO m, AlignmentK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- padding_top+    Word32 ->                               -- padding_bottom+    Word32 ->                               -- padding_left+    Word32 ->                               -- padding_right+    m ()+alignmentSetPadding _obj padding_top padding_bottom padding_left padding_right = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_alignment_set_padding _obj' padding_top padding_bottom padding_left padding_right+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Alignment.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.Alignment where++import Prelude ()+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 Alignment = Alignment (ForeignPtr Alignment)+instance GObject Alignment where+class GObject o => AlignmentK o+instance (GObject o, IsDescendantOf Alignment o) => AlignmentK o+data AlignmentBottomPaddingPropertyInfo+data AlignmentLeftPaddingPropertyInfo+data AlignmentRightPaddingPropertyInfo+data AlignmentTopPaddingPropertyInfo+data AlignmentXalignPropertyInfo+data AlignmentXscalePropertyInfo+data AlignmentYalignPropertyInfo+data AlignmentYscalePropertyInfo
+ GI/Gtk/Objects/AppChooserButton.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.Gtk.Objects.AppChooserButton+    ( ++-- * Exported types+    AppChooserButton(..)                    ,+    AppChooserButtonK                       ,+    toAppChooserButton                      ,+    noAppChooserButton                      ,+++ -- * Methods+-- ** appChooserButtonAppendCustomItem+    appChooserButtonAppendCustomItem        ,+++-- ** appChooserButtonAppendSeparator+    appChooserButtonAppendSeparator         ,+++-- ** appChooserButtonGetHeading+    appChooserButtonGetHeading              ,+++-- ** appChooserButtonGetShowDefaultItem+    appChooserButtonGetShowDefaultItem      ,+++-- ** appChooserButtonGetShowDialogItem+    appChooserButtonGetShowDialogItem       ,+++-- ** appChooserButtonNew+    appChooserButtonNew                     ,+++-- ** appChooserButtonSetActiveCustomItem+    appChooserButtonSetActiveCustomItem     ,+++-- ** appChooserButtonSetHeading+    appChooserButtonSetHeading              ,+++-- ** appChooserButtonSetShowDefaultItem+    appChooserButtonSetShowDefaultItem      ,+++-- ** appChooserButtonSetShowDialogItem+    appChooserButtonSetShowDialogItem       ,+++++ -- * Properties+-- ** Heading+    AppChooserButtonHeadingPropertyInfo     ,+    constructAppChooserButtonHeading        ,+    getAppChooserButtonHeading              ,+    setAppChooserButtonHeading              ,+++-- ** ShowDefaultItem+    AppChooserButtonShowDefaultItemPropertyInfo,+    constructAppChooserButtonShowDefaultItem,+    getAppChooserButtonShowDefaultItem      ,+    setAppChooserButtonShowDefaultItem      ,+++-- ** ShowDialogItem+    AppChooserButtonShowDialogItemPropertyInfo,+    constructAppChooserButtonShowDialogItem ,+    getAppChooserButtonShowDialogItem       ,+    setAppChooserButtonShowDialogItem       ,+++++ -- * Signals+-- ** CustomItemActivated+    AppChooserButtonCustomItemActivatedCallback,+    AppChooserButtonCustomItemActivatedCallbackC,+    AppChooserButtonCustomItemActivatedSignalInfo,+    afterAppChooserButtonCustomItemActivated,+    appChooserButtonCustomItemActivatedCallbackWrapper,+    appChooserButtonCustomItemActivatedClosure,+    mkAppChooserButtonCustomItemActivatedCallback,+    noAppChooserButtonCustomItemActivatedCallback,+    onAppChooserButtonCustomItemActivated   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype AppChooserButton = AppChooserButton (ForeignPtr AppChooserButton)+foreign import ccall "gtk_app_chooser_button_get_type"+    c_gtk_app_chooser_button_get_type :: IO GType++type instance ParentTypes AppChooserButton = AppChooserButtonParentTypes+type AppChooserButtonParentTypes = '[ComboBox, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, AppChooser, Buildable, CellEditable, CellLayout]++instance GObject AppChooserButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_app_chooser_button_get_type+    ++class GObject o => AppChooserButtonK o+instance (GObject o, IsDescendantOf AppChooserButton o) => AppChooserButtonK o++toAppChooserButton :: AppChooserButtonK o => o -> IO AppChooserButton+toAppChooserButton = unsafeCastTo AppChooserButton++noAppChooserButton :: Maybe AppChooserButton+noAppChooserButton = Nothing++-- signal AppChooserButton::custom-item-activated+type AppChooserButtonCustomItemActivatedCallback =+    T.Text ->+    IO ()++noAppChooserButtonCustomItemActivatedCallback :: Maybe AppChooserButtonCustomItemActivatedCallback+noAppChooserButtonCustomItemActivatedCallback = Nothing++type AppChooserButtonCustomItemActivatedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppChooserButtonCustomItemActivatedCallback :: AppChooserButtonCustomItemActivatedCallbackC -> IO (FunPtr AppChooserButtonCustomItemActivatedCallbackC)++appChooserButtonCustomItemActivatedClosure :: AppChooserButtonCustomItemActivatedCallback -> IO Closure+appChooserButtonCustomItemActivatedClosure cb = newCClosure =<< mkAppChooserButtonCustomItemActivatedCallback wrapped+    where wrapped = appChooserButtonCustomItemActivatedCallbackWrapper cb++appChooserButtonCustomItemActivatedCallbackWrapper ::+    AppChooserButtonCustomItemActivatedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+appChooserButtonCustomItemActivatedCallbackWrapper _cb _ item_name _ = do+    item_name' <- cstringToText item_name+    _cb  item_name'++onAppChooserButtonCustomItemActivated :: (GObject a, MonadIO m) => a -> AppChooserButtonCustomItemActivatedCallback -> m SignalHandlerId+onAppChooserButtonCustomItemActivated obj cb = liftIO $ connectAppChooserButtonCustomItemActivated obj cb SignalConnectBefore+afterAppChooserButtonCustomItemActivated :: (GObject a, MonadIO m) => a -> AppChooserButtonCustomItemActivatedCallback -> m SignalHandlerId+afterAppChooserButtonCustomItemActivated obj cb = connectAppChooserButtonCustomItemActivated obj cb SignalConnectAfter++connectAppChooserButtonCustomItemActivated :: (GObject a, MonadIO m) =>+                                              a -> AppChooserButtonCustomItemActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppChooserButtonCustomItemActivated obj cb after = liftIO $ do+    cb' <- mkAppChooserButtonCustomItemActivatedCallback (appChooserButtonCustomItemActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "custom-item-activated" cb' after++-- VVV Prop "heading"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAppChooserButtonHeading :: (MonadIO m, AppChooserButtonK o) => o -> m T.Text+getAppChooserButtonHeading obj = liftIO $ getObjectPropertyString obj "heading"++setAppChooserButtonHeading :: (MonadIO m, AppChooserButtonK o) => o -> T.Text -> m ()+setAppChooserButtonHeading obj val = liftIO $ setObjectPropertyString obj "heading" val++constructAppChooserButtonHeading :: T.Text -> IO ([Char], GValue)+constructAppChooserButtonHeading val = constructObjectPropertyString "heading" val++data AppChooserButtonHeadingPropertyInfo+instance AttrInfo AppChooserButtonHeadingPropertyInfo where+    type AttrAllowedOps AppChooserButtonHeadingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserButtonHeadingPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AppChooserButtonHeadingPropertyInfo = AppChooserButtonK+    type AttrGetType AppChooserButtonHeadingPropertyInfo = T.Text+    type AttrLabel AppChooserButtonHeadingPropertyInfo = "AppChooserButton::heading"+    attrGet _ = getAppChooserButtonHeading+    attrSet _ = setAppChooserButtonHeading+    attrConstruct _ = constructAppChooserButtonHeading++-- VVV Prop "show-default-item"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserButtonShowDefaultItem :: (MonadIO m, AppChooserButtonK o) => o -> m Bool+getAppChooserButtonShowDefaultItem obj = liftIO $ getObjectPropertyBool obj "show-default-item"++setAppChooserButtonShowDefaultItem :: (MonadIO m, AppChooserButtonK o) => o -> Bool -> m ()+setAppChooserButtonShowDefaultItem obj val = liftIO $ setObjectPropertyBool obj "show-default-item" val++constructAppChooserButtonShowDefaultItem :: Bool -> IO ([Char], GValue)+constructAppChooserButtonShowDefaultItem val = constructObjectPropertyBool "show-default-item" val++data AppChooserButtonShowDefaultItemPropertyInfo+instance AttrInfo AppChooserButtonShowDefaultItemPropertyInfo where+    type AttrAllowedOps AppChooserButtonShowDefaultItemPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserButtonShowDefaultItemPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserButtonShowDefaultItemPropertyInfo = AppChooserButtonK+    type AttrGetType AppChooserButtonShowDefaultItemPropertyInfo = Bool+    type AttrLabel AppChooserButtonShowDefaultItemPropertyInfo = "AppChooserButton::show-default-item"+    attrGet _ = getAppChooserButtonShowDefaultItem+    attrSet _ = setAppChooserButtonShowDefaultItem+    attrConstruct _ = constructAppChooserButtonShowDefaultItem++-- VVV Prop "show-dialog-item"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserButtonShowDialogItem :: (MonadIO m, AppChooserButtonK o) => o -> m Bool+getAppChooserButtonShowDialogItem obj = liftIO $ getObjectPropertyBool obj "show-dialog-item"++setAppChooserButtonShowDialogItem :: (MonadIO m, AppChooserButtonK o) => o -> Bool -> m ()+setAppChooserButtonShowDialogItem obj val = liftIO $ setObjectPropertyBool obj "show-dialog-item" val++constructAppChooserButtonShowDialogItem :: Bool -> IO ([Char], GValue)+constructAppChooserButtonShowDialogItem val = constructObjectPropertyBool "show-dialog-item" val++data AppChooserButtonShowDialogItemPropertyInfo+instance AttrInfo AppChooserButtonShowDialogItemPropertyInfo where+    type AttrAllowedOps AppChooserButtonShowDialogItemPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserButtonShowDialogItemPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserButtonShowDialogItemPropertyInfo = AppChooserButtonK+    type AttrGetType AppChooserButtonShowDialogItemPropertyInfo = Bool+    type AttrLabel AppChooserButtonShowDialogItemPropertyInfo = "AppChooserButton::show-dialog-item"+    attrGet _ = getAppChooserButtonShowDialogItem+    attrSet _ = setAppChooserButtonShowDialogItem+    attrConstruct _ = constructAppChooserButtonShowDialogItem++type instance AttributeList AppChooserButton = AppChooserButtonAttributeList+type AppChooserButtonAttributeList = ('[ '("active", ComboBoxActivePropertyInfo), '("active-id", ComboBoxActiveIdPropertyInfo), '("add-tearoffs", ComboBoxAddTearoffsPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("button-sensitivity", ComboBoxButtonSensitivityPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cell-area", ComboBoxCellAreaPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-span-column", ComboBoxColumnSpanColumnPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("content-type", AppChooserContentTypePropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("editing-canceled", CellEditableEditingCanceledPropertyInfo), '("entry-text-column", ComboBoxEntryTextColumnPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ComboBoxFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-entry", ComboBoxHasEntryPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-frame", ComboBoxHasFramePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("heading", AppChooserButtonHeadingPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("id-column", ComboBoxIdColumnPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("model", ComboBoxModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("popup-fixed-width", ComboBoxPopupFixedWidthPropertyInfo), '("popup-shown", ComboBoxPopupShownPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-span-column", ComboBoxRowSpanColumnPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-default-item", AppChooserButtonShowDefaultItemPropertyInfo), '("show-dialog-item", AppChooserButtonShowDialogItemPropertyInfo), '("style", WidgetStylePropertyInfo), '("tearoff-title", ComboBoxTearoffTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("wrap-width", ComboBoxWrapWidthPropertyInfo)] :: [(Symbol, *)])++data AppChooserButtonCustomItemActivatedSignalInfo+instance SignalInfo AppChooserButtonCustomItemActivatedSignalInfo where+    type HaskellCallbackType AppChooserButtonCustomItemActivatedSignalInfo = AppChooserButtonCustomItemActivatedCallback+    connectSignal _ = connectAppChooserButtonCustomItemActivated++type instance SignalList AppChooserButton = AppChooserButtonSignalList+type AppChooserButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("changed", ComboBoxChangedSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("custom-item-activated", AppChooserButtonCustomItemActivatedSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("editing-done", CellEditableEditingDoneSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("format-entry-text", ComboBoxFormatEntryTextSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-active", ComboBoxMoveActiveSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popdown", ComboBoxPopdownSignalInfo), '("popup", ComboBoxPopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("remove-widget", CellEditableRemoveWidgetSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AppChooserButton::new+-- method type : Constructor+-- 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 : TInterface "Gtk" "AppChooserButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_button_new" gtk_app_chooser_button_new :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr AppChooserButton)+++appChooserButtonNew ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m AppChooserButton+appChooserButtonNew content_type = liftIO $ do+    content_type' <- textToCString content_type+    result <- gtk_app_chooser_button_new content_type'+    checkUnexpectedReturnNULL "gtk_app_chooser_button_new" result+    result' <- (newObject AppChooserButton) result+    freeMem content_type'+    return result'++-- method AppChooserButton::append_custom_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", 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 = "label", argType = TBasicType TUTF8, 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 "Gtk" "AppChooserButton", 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 = "label", argType = TBasicType TUTF8, 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 "gtk_app_chooser_button_append_custom_item" gtk_app_chooser_button_append_custom_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    IO ()+++appChooserButtonAppendCustomItem ::+    (MonadIO m, AppChooserButtonK a, Gio.IconK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    T.Text ->                               -- label+    b ->                                    -- icon+    m ()+appChooserButtonAppendCustomItem _obj name label icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    label' <- textToCString label+    let icon' = unsafeManagedPtrCastPtr icon+    gtk_app_chooser_button_append_custom_item _obj' name' label' icon'+    touchManagedPtr _obj+    touchManagedPtr icon+    freeMem name'+    freeMem label'+    return ()++-- method AppChooserButton::append_separator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_button_append_separator" gtk_app_chooser_button_append_separator :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    IO ()+++appChooserButtonAppendSeparator ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    m ()+appChooserButtonAppendSeparator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_app_chooser_button_append_separator _obj'+    touchManagedPtr _obj+    return ()++-- method AppChooserButton::get_heading+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_button_get_heading" gtk_app_chooser_button_get_heading :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    IO CString+++appChooserButtonGetHeading ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    m T.Text+appChooserButtonGetHeading _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_button_get_heading _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_button_get_heading" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppChooserButton::get_show_default_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_button_get_show_default_item" gtk_app_chooser_button_get_show_default_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    IO CInt+++appChooserButtonGetShowDefaultItem ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    m Bool+appChooserButtonGetShowDefaultItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_button_get_show_default_item _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserButton::get_show_dialog_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_button_get_show_dialog_item" gtk_app_chooser_button_get_show_dialog_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    IO CInt+++appChooserButtonGetShowDialogItem ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    m Bool+appChooserButtonGetShowDialogItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_button_get_show_dialog_item _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserButton::set_active_custom_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", 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 "Gtk" "AppChooserButton", 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 "gtk_app_chooser_button_set_active_custom_item" gtk_app_chooser_button_set_active_custom_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++appChooserButtonSetActiveCustomItem ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m ()+appChooserButtonSetActiveCustomItem _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gtk_app_chooser_button_set_active_custom_item _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method AppChooserButton::set_heading+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "heading", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "heading", 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 "gtk_app_chooser_button_set_heading" gtk_app_chooser_button_set_heading :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    CString ->                              -- heading : TBasicType TUTF8+    IO ()+++appChooserButtonSetHeading ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- heading+    m ()+appChooserButtonSetHeading _obj heading = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    heading' <- textToCString heading+    gtk_app_chooser_button_set_heading _obj' heading'+    touchManagedPtr _obj+    freeMem heading'+    return ()++-- method AppChooserButton::set_show_default_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_button_set_show_default_item" gtk_app_chooser_button_set_show_default_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserButtonSetShowDefaultItem ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserButtonSetShowDefaultItem _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_button_set_show_default_item _obj' setting'+    touchManagedPtr _obj+    return ()++-- method AppChooserButton::set_show_dialog_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_button_set_show_dialog_item" gtk_app_chooser_button_set_show_dialog_item :: +    Ptr AppChooserButton ->                 -- _obj : TInterface "Gtk" "AppChooserButton"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserButtonSetShowDialogItem ::+    (MonadIO m, AppChooserButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserButtonSetShowDialogItem _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_button_set_show_dialog_item _obj' setting'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/AppChooserButton.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.AppChooserButton where++import Prelude ()+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 AppChooserButton = AppChooserButton (ForeignPtr AppChooserButton)+instance GObject AppChooserButton where+class GObject o => AppChooserButtonK o+instance (GObject o, IsDescendantOf AppChooserButton o) => AppChooserButtonK o+data AppChooserButtonHeadingPropertyInfo+data AppChooserButtonShowDefaultItemPropertyInfo+data AppChooserButtonShowDialogItemPropertyInfo+data AppChooserButtonCustomItemActivatedSignalInfo
+ GI/Gtk/Objects/AppChooserDialog.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.Gtk.Objects.AppChooserDialog+    ( ++-- * Exported types+    AppChooserDialog(..)                    ,+    AppChooserDialogK                       ,+    toAppChooserDialog                      ,+    noAppChooserDialog                      ,+++ -- * Methods+-- ** appChooserDialogGetHeading+    appChooserDialogGetHeading              ,+++-- ** appChooserDialogGetWidget+    appChooserDialogGetWidget               ,+++-- ** appChooserDialogNew+    appChooserDialogNew                     ,+++-- ** appChooserDialogNewForContentType+    appChooserDialogNewForContentType       ,+++-- ** appChooserDialogSetHeading+    appChooserDialogSetHeading              ,+++++ -- * Properties+-- ** Gfile+    AppChooserDialogGfilePropertyInfo       ,+    constructAppChooserDialogGfile          ,+    getAppChooserDialogGfile                ,+++-- ** Heading+    AppChooserDialogHeadingPropertyInfo     ,+    constructAppChooserDialogHeading        ,+    getAppChooserDialogHeading              ,+    setAppChooserDialogHeading              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype AppChooserDialog = AppChooserDialog (ForeignPtr AppChooserDialog)+foreign import ccall "gtk_app_chooser_dialog_get_type"+    c_gtk_app_chooser_dialog_get_type :: IO GType++type instance ParentTypes AppChooserDialog = AppChooserDialogParentTypes+type AppChooserDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, AppChooser, Buildable]++instance GObject AppChooserDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_app_chooser_dialog_get_type+    ++class GObject o => AppChooserDialogK o+instance (GObject o, IsDescendantOf AppChooserDialog o) => AppChooserDialogK o++toAppChooserDialog :: AppChooserDialogK o => o -> IO AppChooserDialog+toAppChooserDialog = unsafeCastTo AppChooserDialog++noAppChooserDialog :: Maybe AppChooserDialog+noAppChooserDialog = Nothing++-- VVV Prop "gfile"+   -- Type: TInterface "Gio" "File"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getAppChooserDialogGfile :: (MonadIO m, AppChooserDialogK o) => o -> m Gio.File+getAppChooserDialogGfile obj = liftIO $ getObjectPropertyObject obj "gfile" Gio.File++constructAppChooserDialogGfile :: (Gio.FileK a) => a -> IO ([Char], GValue)+constructAppChooserDialogGfile val = constructObjectPropertyObject "gfile" val++data AppChooserDialogGfilePropertyInfo+instance AttrInfo AppChooserDialogGfilePropertyInfo where+    type AttrAllowedOps AppChooserDialogGfilePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserDialogGfilePropertyInfo = Gio.FileK+    type AttrBaseTypeConstraint AppChooserDialogGfilePropertyInfo = AppChooserDialogK+    type AttrGetType AppChooserDialogGfilePropertyInfo = Gio.File+    type AttrLabel AppChooserDialogGfilePropertyInfo = "AppChooserDialog::gfile"+    attrGet _ = getAppChooserDialogGfile+    attrSet _ = undefined+    attrConstruct _ = constructAppChooserDialogGfile++-- VVV Prop "heading"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAppChooserDialogHeading :: (MonadIO m, AppChooserDialogK o) => o -> m T.Text+getAppChooserDialogHeading obj = liftIO $ getObjectPropertyString obj "heading"++setAppChooserDialogHeading :: (MonadIO m, AppChooserDialogK o) => o -> T.Text -> m ()+setAppChooserDialogHeading obj val = liftIO $ setObjectPropertyString obj "heading" val++constructAppChooserDialogHeading :: T.Text -> IO ([Char], GValue)+constructAppChooserDialogHeading val = constructObjectPropertyString "heading" val++data AppChooserDialogHeadingPropertyInfo+instance AttrInfo AppChooserDialogHeadingPropertyInfo where+    type AttrAllowedOps AppChooserDialogHeadingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserDialogHeadingPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AppChooserDialogHeadingPropertyInfo = AppChooserDialogK+    type AttrGetType AppChooserDialogHeadingPropertyInfo = T.Text+    type AttrLabel AppChooserDialogHeadingPropertyInfo = "AppChooserDialog::heading"+    attrGet _ = getAppChooserDialogHeading+    attrSet _ = setAppChooserDialogHeading+    attrConstruct _ = constructAppChooserDialogHeading++type instance AttributeList AppChooserDialog = AppChooserDialogAttributeList+type AppChooserDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("content-type", AppChooserContentTypePropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gfile", AppChooserDialogGfilePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("heading", AppChooserDialogHeadingPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList AppChooserDialog = AppChooserDialogSignalList+type AppChooserDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AppChooserDialog::new+-- method type : Constructor+-- Args : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "DialogFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "DialogFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AppChooserDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_dialog_new" gtk_app_chooser_dialog_new :: +    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    CUInt ->                                -- flags : TInterface "Gtk" "DialogFlags"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    IO (Ptr AppChooserDialog)+++appChooserDialogNew ::+    (MonadIO m, WindowK a, Gio.FileK b) =>+    Maybe (a) ->                            -- parent+    [DialogFlags] ->                        -- flags+    b ->                                    -- file+    m AppChooserDialog+appChooserDialogNew parent flags file = liftIO $ do+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    let flags' = gflagsToWord flags+    let file' = unsafeManagedPtrCastPtr file+    result <- gtk_app_chooser_dialog_new maybeParent flags' file'+    checkUnexpectedReturnNULL "gtk_app_chooser_dialog_new" result+    result' <- (newObject AppChooserDialog) result+    whenJust parent touchManagedPtr+    touchManagedPtr file+    return result'++-- method AppChooserDialog::new_for_content_type+-- method type : Constructor+-- Args : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "DialogFlags", 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 = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "DialogFlags", 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 : TInterface "Gtk" "AppChooserDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_dialog_new_for_content_type" gtk_app_chooser_dialog_new_for_content_type :: +    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    CUInt ->                                -- flags : TInterface "Gtk" "DialogFlags"+    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr AppChooserDialog)+++appChooserDialogNewForContentType ::+    (MonadIO m, WindowK a) =>+    Maybe (a) ->                            -- parent+    [DialogFlags] ->                        -- flags+    T.Text ->                               -- content_type+    m AppChooserDialog+appChooserDialogNewForContentType parent flags content_type = liftIO $ do+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    let flags' = gflagsToWord flags+    content_type' <- textToCString content_type+    result <- gtk_app_chooser_dialog_new_for_content_type maybeParent flags' content_type'+    checkUnexpectedReturnNULL "gtk_app_chooser_dialog_new_for_content_type" result+    result' <- (newObject AppChooserDialog) result+    whenJust parent touchManagedPtr+    freeMem content_type'+    return result'++-- method AppChooserDialog::get_heading+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_dialog_get_heading" gtk_app_chooser_dialog_get_heading :: +    Ptr AppChooserDialog ->                 -- _obj : TInterface "Gtk" "AppChooserDialog"+    IO CString+++appChooserDialogGetHeading ::+    (MonadIO m, AppChooserDialogK a) =>+    a ->                                    -- _obj+    m T.Text+appChooserDialogGetHeading _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_dialog_get_heading _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_dialog_get_heading" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppChooserDialog::get_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_dialog_get_widget" gtk_app_chooser_dialog_get_widget :: +    Ptr AppChooserDialog ->                 -- _obj : TInterface "Gtk" "AppChooserDialog"+    IO (Ptr Widget)+++appChooserDialogGetWidget ::+    (MonadIO m, AppChooserDialogK a) =>+    a ->                                    -- _obj+    m Widget+appChooserDialogGetWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_dialog_get_widget _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_dialog_get_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method AppChooserDialog::set_heading+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "heading", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "heading", 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 "gtk_app_chooser_dialog_set_heading" gtk_app_chooser_dialog_set_heading :: +    Ptr AppChooserDialog ->                 -- _obj : TInterface "Gtk" "AppChooserDialog"+    CString ->                              -- heading : TBasicType TUTF8+    IO ()+++appChooserDialogSetHeading ::+    (MonadIO m, AppChooserDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- heading+    m ()+appChooserDialogSetHeading _obj heading = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    heading' <- textToCString heading+    gtk_app_chooser_dialog_set_heading _obj' heading'+    touchManagedPtr _obj+    freeMem heading'+    return ()++
+ GI/Gtk/Objects/AppChooserDialog.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.AppChooserDialog where++import Prelude ()+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 AppChooserDialog = AppChooserDialog (ForeignPtr AppChooserDialog)+instance GObject AppChooserDialog where+class GObject o => AppChooserDialogK o+instance (GObject o, IsDescendantOf AppChooserDialog o) => AppChooserDialogK o+data AppChooserDialogGfilePropertyInfo+data AppChooserDialogHeadingPropertyInfo
+ GI/Gtk/Objects/AppChooserWidget.hs view
@@ -0,0 +1,828 @@++{- |+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.Gtk.Objects.AppChooserWidget+    ( ++-- * Exported types+    AppChooserWidget(..)                    ,+    AppChooserWidgetK                       ,+    toAppChooserWidget                      ,+    noAppChooserWidget                      ,+++ -- * Methods+-- ** appChooserWidgetGetDefaultText+    appChooserWidgetGetDefaultText          ,+++-- ** appChooserWidgetGetShowAll+    appChooserWidgetGetShowAll              ,+++-- ** appChooserWidgetGetShowDefault+    appChooserWidgetGetShowDefault          ,+++-- ** appChooserWidgetGetShowFallback+    appChooserWidgetGetShowFallback         ,+++-- ** appChooserWidgetGetShowOther+    appChooserWidgetGetShowOther            ,+++-- ** appChooserWidgetGetShowRecommended+    appChooserWidgetGetShowRecommended      ,+++-- ** appChooserWidgetNew+    appChooserWidgetNew                     ,+++-- ** appChooserWidgetSetDefaultText+    appChooserWidgetSetDefaultText          ,+++-- ** appChooserWidgetSetShowAll+    appChooserWidgetSetShowAll              ,+++-- ** appChooserWidgetSetShowDefault+    appChooserWidgetSetShowDefault          ,+++-- ** appChooserWidgetSetShowFallback+    appChooserWidgetSetShowFallback         ,+++-- ** appChooserWidgetSetShowOther+    appChooserWidgetSetShowOther            ,+++-- ** appChooserWidgetSetShowRecommended+    appChooserWidgetSetShowRecommended      ,+++++ -- * Properties+-- ** DefaultText+    AppChooserWidgetDefaultTextPropertyInfo ,+    constructAppChooserWidgetDefaultText    ,+    getAppChooserWidgetDefaultText          ,+    setAppChooserWidgetDefaultText          ,+++-- ** ShowAll+    AppChooserWidgetShowAllPropertyInfo     ,+    constructAppChooserWidgetShowAll        ,+    getAppChooserWidgetShowAll              ,+    setAppChooserWidgetShowAll              ,+++-- ** ShowDefault+    AppChooserWidgetShowDefaultPropertyInfo ,+    constructAppChooserWidgetShowDefault    ,+    getAppChooserWidgetShowDefault          ,+    setAppChooserWidgetShowDefault          ,+++-- ** ShowFallback+    AppChooserWidgetShowFallbackPropertyInfo,+    constructAppChooserWidgetShowFallback   ,+    getAppChooserWidgetShowFallback         ,+    setAppChooserWidgetShowFallback         ,+++-- ** ShowOther+    AppChooserWidgetShowOtherPropertyInfo   ,+    constructAppChooserWidgetShowOther      ,+    getAppChooserWidgetShowOther            ,+    setAppChooserWidgetShowOther            ,+++-- ** ShowRecommended+    AppChooserWidgetShowRecommendedPropertyInfo,+    constructAppChooserWidgetShowRecommended,+    getAppChooserWidgetShowRecommended      ,+    setAppChooserWidgetShowRecommended      ,+++++ -- * Signals+-- ** ApplicationActivated+    AppChooserWidgetApplicationActivatedCallback,+    AppChooserWidgetApplicationActivatedCallbackC,+    AppChooserWidgetApplicationActivatedSignalInfo,+    afterAppChooserWidgetApplicationActivated,+    appChooserWidgetApplicationActivatedCallbackWrapper,+    appChooserWidgetApplicationActivatedClosure,+    mkAppChooserWidgetApplicationActivatedCallback,+    noAppChooserWidgetApplicationActivatedCallback,+    onAppChooserWidgetApplicationActivated  ,+++-- ** ApplicationSelected+    AppChooserWidgetApplicationSelectedCallback,+    AppChooserWidgetApplicationSelectedCallbackC,+    AppChooserWidgetApplicationSelectedSignalInfo,+    afterAppChooserWidgetApplicationSelected,+    appChooserWidgetApplicationSelectedCallbackWrapper,+    appChooserWidgetApplicationSelectedClosure,+    mkAppChooserWidgetApplicationSelectedCallback,+    noAppChooserWidgetApplicationSelectedCallback,+    onAppChooserWidgetApplicationSelected   ,+++-- ** PopulatePopup+    AppChooserWidgetPopulatePopupCallback   ,+    AppChooserWidgetPopulatePopupCallbackC  ,+    AppChooserWidgetPopulatePopupSignalInfo ,+    afterAppChooserWidgetPopulatePopup      ,+    appChooserWidgetPopulatePopupCallbackWrapper,+    appChooserWidgetPopulatePopupClosure    ,+    mkAppChooserWidgetPopulatePopupCallback ,+    noAppChooserWidgetPopulatePopupCallback ,+    onAppChooserWidgetPopulatePopup         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype AppChooserWidget = AppChooserWidget (ForeignPtr AppChooserWidget)+foreign import ccall "gtk_app_chooser_widget_get_type"+    c_gtk_app_chooser_widget_get_type :: IO GType++type instance ParentTypes AppChooserWidget = AppChooserWidgetParentTypes+type AppChooserWidgetParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, AppChooser, Buildable, Orientable]++instance GObject AppChooserWidget where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_app_chooser_widget_get_type+    ++class GObject o => AppChooserWidgetK o+instance (GObject o, IsDescendantOf AppChooserWidget o) => AppChooserWidgetK o++toAppChooserWidget :: AppChooserWidgetK o => o -> IO AppChooserWidget+toAppChooserWidget = unsafeCastTo AppChooserWidget++noAppChooserWidget :: Maybe AppChooserWidget+noAppChooserWidget = Nothing++-- signal AppChooserWidget::application-activated+type AppChooserWidgetApplicationActivatedCallback =+    Gio.AppInfo ->+    IO ()++noAppChooserWidgetApplicationActivatedCallback :: Maybe AppChooserWidgetApplicationActivatedCallback+noAppChooserWidgetApplicationActivatedCallback = Nothing++type AppChooserWidgetApplicationActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr Gio.AppInfo ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppChooserWidgetApplicationActivatedCallback :: AppChooserWidgetApplicationActivatedCallbackC -> IO (FunPtr AppChooserWidgetApplicationActivatedCallbackC)++appChooserWidgetApplicationActivatedClosure :: AppChooserWidgetApplicationActivatedCallback -> IO Closure+appChooserWidgetApplicationActivatedClosure cb = newCClosure =<< mkAppChooserWidgetApplicationActivatedCallback wrapped+    where wrapped = appChooserWidgetApplicationActivatedCallbackWrapper cb++appChooserWidgetApplicationActivatedCallbackWrapper ::+    AppChooserWidgetApplicationActivatedCallback ->+    Ptr () ->+    Ptr Gio.AppInfo ->+    Ptr () ->+    IO ()+appChooserWidgetApplicationActivatedCallbackWrapper _cb _ application _ = do+    application' <- (newObject Gio.AppInfo) application+    _cb  application'++onAppChooserWidgetApplicationActivated :: (GObject a, MonadIO m) => a -> AppChooserWidgetApplicationActivatedCallback -> m SignalHandlerId+onAppChooserWidgetApplicationActivated obj cb = liftIO $ connectAppChooserWidgetApplicationActivated obj cb SignalConnectBefore+afterAppChooserWidgetApplicationActivated :: (GObject a, MonadIO m) => a -> AppChooserWidgetApplicationActivatedCallback -> m SignalHandlerId+afterAppChooserWidgetApplicationActivated obj cb = connectAppChooserWidgetApplicationActivated obj cb SignalConnectAfter++connectAppChooserWidgetApplicationActivated :: (GObject a, MonadIO m) =>+                                               a -> AppChooserWidgetApplicationActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppChooserWidgetApplicationActivated obj cb after = liftIO $ do+    cb' <- mkAppChooserWidgetApplicationActivatedCallback (appChooserWidgetApplicationActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "application-activated" cb' after++-- signal AppChooserWidget::application-selected+type AppChooserWidgetApplicationSelectedCallback =+    Gio.AppInfo ->+    IO ()++noAppChooserWidgetApplicationSelectedCallback :: Maybe AppChooserWidgetApplicationSelectedCallback+noAppChooserWidgetApplicationSelectedCallback = Nothing++type AppChooserWidgetApplicationSelectedCallbackC =+    Ptr () ->                               -- object+    Ptr Gio.AppInfo ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppChooserWidgetApplicationSelectedCallback :: AppChooserWidgetApplicationSelectedCallbackC -> IO (FunPtr AppChooserWidgetApplicationSelectedCallbackC)++appChooserWidgetApplicationSelectedClosure :: AppChooserWidgetApplicationSelectedCallback -> IO Closure+appChooserWidgetApplicationSelectedClosure cb = newCClosure =<< mkAppChooserWidgetApplicationSelectedCallback wrapped+    where wrapped = appChooserWidgetApplicationSelectedCallbackWrapper cb++appChooserWidgetApplicationSelectedCallbackWrapper ::+    AppChooserWidgetApplicationSelectedCallback ->+    Ptr () ->+    Ptr Gio.AppInfo ->+    Ptr () ->+    IO ()+appChooserWidgetApplicationSelectedCallbackWrapper _cb _ application _ = do+    application' <- (newObject Gio.AppInfo) application+    _cb  application'++onAppChooserWidgetApplicationSelected :: (GObject a, MonadIO m) => a -> AppChooserWidgetApplicationSelectedCallback -> m SignalHandlerId+onAppChooserWidgetApplicationSelected obj cb = liftIO $ connectAppChooserWidgetApplicationSelected obj cb SignalConnectBefore+afterAppChooserWidgetApplicationSelected :: (GObject a, MonadIO m) => a -> AppChooserWidgetApplicationSelectedCallback -> m SignalHandlerId+afterAppChooserWidgetApplicationSelected obj cb = connectAppChooserWidgetApplicationSelected obj cb SignalConnectAfter++connectAppChooserWidgetApplicationSelected :: (GObject a, MonadIO m) =>+                                              a -> AppChooserWidgetApplicationSelectedCallback -> SignalConnectMode -> m SignalHandlerId+connectAppChooserWidgetApplicationSelected obj cb after = liftIO $ do+    cb' <- mkAppChooserWidgetApplicationSelectedCallback (appChooserWidgetApplicationSelectedCallbackWrapper cb)+    connectSignalFunPtr obj "application-selected" cb' after++-- signal AppChooserWidget::populate-popup+type AppChooserWidgetPopulatePopupCallback =+    Menu ->+    Gio.AppInfo ->+    IO ()++noAppChooserWidgetPopulatePopupCallback :: Maybe AppChooserWidgetPopulatePopupCallback+noAppChooserWidgetPopulatePopupCallback = Nothing++type AppChooserWidgetPopulatePopupCallbackC =+    Ptr () ->                               -- object+    Ptr Menu ->+    Ptr Gio.AppInfo ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAppChooserWidgetPopulatePopupCallback :: AppChooserWidgetPopulatePopupCallbackC -> IO (FunPtr AppChooserWidgetPopulatePopupCallbackC)++appChooserWidgetPopulatePopupClosure :: AppChooserWidgetPopulatePopupCallback -> IO Closure+appChooserWidgetPopulatePopupClosure cb = newCClosure =<< mkAppChooserWidgetPopulatePopupCallback wrapped+    where wrapped = appChooserWidgetPopulatePopupCallbackWrapper cb++appChooserWidgetPopulatePopupCallbackWrapper ::+    AppChooserWidgetPopulatePopupCallback ->+    Ptr () ->+    Ptr Menu ->+    Ptr Gio.AppInfo ->+    Ptr () ->+    IO ()+appChooserWidgetPopulatePopupCallbackWrapper _cb _ menu application _ = do+    menu' <- (newObject Menu) menu+    application' <- (newObject Gio.AppInfo) application+    _cb  menu' application'++onAppChooserWidgetPopulatePopup :: (GObject a, MonadIO m) => a -> AppChooserWidgetPopulatePopupCallback -> m SignalHandlerId+onAppChooserWidgetPopulatePopup obj cb = liftIO $ connectAppChooserWidgetPopulatePopup obj cb SignalConnectBefore+afterAppChooserWidgetPopulatePopup :: (GObject a, MonadIO m) => a -> AppChooserWidgetPopulatePopupCallback -> m SignalHandlerId+afterAppChooserWidgetPopulatePopup obj cb = connectAppChooserWidgetPopulatePopup obj cb SignalConnectAfter++connectAppChooserWidgetPopulatePopup :: (GObject a, MonadIO m) =>+                                        a -> AppChooserWidgetPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId+connectAppChooserWidgetPopulatePopup obj cb after = liftIO $ do+    cb' <- mkAppChooserWidgetPopulatePopupCallback (appChooserWidgetPopulatePopupCallbackWrapper cb)+    connectSignalFunPtr obj "populate-popup" cb' after++-- VVV Prop "default-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getAppChooserWidgetDefaultText :: (MonadIO m, AppChooserWidgetK o) => o -> m T.Text+getAppChooserWidgetDefaultText obj = liftIO $ getObjectPropertyString obj "default-text"++setAppChooserWidgetDefaultText :: (MonadIO m, AppChooserWidgetK o) => o -> T.Text -> m ()+setAppChooserWidgetDefaultText obj val = liftIO $ setObjectPropertyString obj "default-text" val++constructAppChooserWidgetDefaultText :: T.Text -> IO ([Char], GValue)+constructAppChooserWidgetDefaultText val = constructObjectPropertyString "default-text" val++data AppChooserWidgetDefaultTextPropertyInfo+instance AttrInfo AppChooserWidgetDefaultTextPropertyInfo where+    type AttrAllowedOps AppChooserWidgetDefaultTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetDefaultTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint AppChooserWidgetDefaultTextPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetDefaultTextPropertyInfo = T.Text+    type AttrLabel AppChooserWidgetDefaultTextPropertyInfo = "AppChooserWidget::default-text"+    attrGet _ = getAppChooserWidgetDefaultText+    attrSet _ = setAppChooserWidgetDefaultText+    attrConstruct _ = constructAppChooserWidgetDefaultText++-- VVV Prop "show-all"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserWidgetShowAll :: (MonadIO m, AppChooserWidgetK o) => o -> m Bool+getAppChooserWidgetShowAll obj = liftIO $ getObjectPropertyBool obj "show-all"++setAppChooserWidgetShowAll :: (MonadIO m, AppChooserWidgetK o) => o -> Bool -> m ()+setAppChooserWidgetShowAll obj val = liftIO $ setObjectPropertyBool obj "show-all" val++constructAppChooserWidgetShowAll :: Bool -> IO ([Char], GValue)+constructAppChooserWidgetShowAll val = constructObjectPropertyBool "show-all" val++data AppChooserWidgetShowAllPropertyInfo+instance AttrInfo AppChooserWidgetShowAllPropertyInfo where+    type AttrAllowedOps AppChooserWidgetShowAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetShowAllPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserWidgetShowAllPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetShowAllPropertyInfo = Bool+    type AttrLabel AppChooserWidgetShowAllPropertyInfo = "AppChooserWidget::show-all"+    attrGet _ = getAppChooserWidgetShowAll+    attrSet _ = setAppChooserWidgetShowAll+    attrConstruct _ = constructAppChooserWidgetShowAll++-- VVV Prop "show-default"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserWidgetShowDefault :: (MonadIO m, AppChooserWidgetK o) => o -> m Bool+getAppChooserWidgetShowDefault obj = liftIO $ getObjectPropertyBool obj "show-default"++setAppChooserWidgetShowDefault :: (MonadIO m, AppChooserWidgetK o) => o -> Bool -> m ()+setAppChooserWidgetShowDefault obj val = liftIO $ setObjectPropertyBool obj "show-default" val++constructAppChooserWidgetShowDefault :: Bool -> IO ([Char], GValue)+constructAppChooserWidgetShowDefault val = constructObjectPropertyBool "show-default" val++data AppChooserWidgetShowDefaultPropertyInfo+instance AttrInfo AppChooserWidgetShowDefaultPropertyInfo where+    type AttrAllowedOps AppChooserWidgetShowDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetShowDefaultPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserWidgetShowDefaultPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetShowDefaultPropertyInfo = Bool+    type AttrLabel AppChooserWidgetShowDefaultPropertyInfo = "AppChooserWidget::show-default"+    attrGet _ = getAppChooserWidgetShowDefault+    attrSet _ = setAppChooserWidgetShowDefault+    attrConstruct _ = constructAppChooserWidgetShowDefault++-- VVV Prop "show-fallback"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserWidgetShowFallback :: (MonadIO m, AppChooserWidgetK o) => o -> m Bool+getAppChooserWidgetShowFallback obj = liftIO $ getObjectPropertyBool obj "show-fallback"++setAppChooserWidgetShowFallback :: (MonadIO m, AppChooserWidgetK o) => o -> Bool -> m ()+setAppChooserWidgetShowFallback obj val = liftIO $ setObjectPropertyBool obj "show-fallback" val++constructAppChooserWidgetShowFallback :: Bool -> IO ([Char], GValue)+constructAppChooserWidgetShowFallback val = constructObjectPropertyBool "show-fallback" val++data AppChooserWidgetShowFallbackPropertyInfo+instance AttrInfo AppChooserWidgetShowFallbackPropertyInfo where+    type AttrAllowedOps AppChooserWidgetShowFallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetShowFallbackPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserWidgetShowFallbackPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetShowFallbackPropertyInfo = Bool+    type AttrLabel AppChooserWidgetShowFallbackPropertyInfo = "AppChooserWidget::show-fallback"+    attrGet _ = getAppChooserWidgetShowFallback+    attrSet _ = setAppChooserWidgetShowFallback+    attrConstruct _ = constructAppChooserWidgetShowFallback++-- VVV Prop "show-other"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserWidgetShowOther :: (MonadIO m, AppChooserWidgetK o) => o -> m Bool+getAppChooserWidgetShowOther obj = liftIO $ getObjectPropertyBool obj "show-other"++setAppChooserWidgetShowOther :: (MonadIO m, AppChooserWidgetK o) => o -> Bool -> m ()+setAppChooserWidgetShowOther obj val = liftIO $ setObjectPropertyBool obj "show-other" val++constructAppChooserWidgetShowOther :: Bool -> IO ([Char], GValue)+constructAppChooserWidgetShowOther val = constructObjectPropertyBool "show-other" val++data AppChooserWidgetShowOtherPropertyInfo+instance AttrInfo AppChooserWidgetShowOtherPropertyInfo where+    type AttrAllowedOps AppChooserWidgetShowOtherPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetShowOtherPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserWidgetShowOtherPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetShowOtherPropertyInfo = Bool+    type AttrLabel AppChooserWidgetShowOtherPropertyInfo = "AppChooserWidget::show-other"+    attrGet _ = getAppChooserWidgetShowOther+    attrSet _ = setAppChooserWidgetShowOther+    attrConstruct _ = constructAppChooserWidgetShowOther++-- VVV Prop "show-recommended"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getAppChooserWidgetShowRecommended :: (MonadIO m, AppChooserWidgetK o) => o -> m Bool+getAppChooserWidgetShowRecommended obj = liftIO $ getObjectPropertyBool obj "show-recommended"++setAppChooserWidgetShowRecommended :: (MonadIO m, AppChooserWidgetK o) => o -> Bool -> m ()+setAppChooserWidgetShowRecommended obj val = liftIO $ setObjectPropertyBool obj "show-recommended" val++constructAppChooserWidgetShowRecommended :: Bool -> IO ([Char], GValue)+constructAppChooserWidgetShowRecommended val = constructObjectPropertyBool "show-recommended" val++data AppChooserWidgetShowRecommendedPropertyInfo+instance AttrInfo AppChooserWidgetShowRecommendedPropertyInfo where+    type AttrAllowedOps AppChooserWidgetShowRecommendedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AppChooserWidgetShowRecommendedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AppChooserWidgetShowRecommendedPropertyInfo = AppChooserWidgetK+    type AttrGetType AppChooserWidgetShowRecommendedPropertyInfo = Bool+    type AttrLabel AppChooserWidgetShowRecommendedPropertyInfo = "AppChooserWidget::show-recommended"+    attrGet _ = getAppChooserWidgetShowRecommended+    attrSet _ = setAppChooserWidgetShowRecommended+    attrConstruct _ = constructAppChooserWidgetShowRecommended++type instance AttributeList AppChooserWidget = AppChooserWidgetAttributeList+type AppChooserWidgetAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("content-type", AppChooserContentTypePropertyInfo), '("default-text", AppChooserWidgetDefaultTextPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-all", AppChooserWidgetShowAllPropertyInfo), '("show-default", AppChooserWidgetShowDefaultPropertyInfo), '("show-fallback", AppChooserWidgetShowFallbackPropertyInfo), '("show-other", AppChooserWidgetShowOtherPropertyInfo), '("show-recommended", AppChooserWidgetShowRecommendedPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data AppChooserWidgetApplicationActivatedSignalInfo+instance SignalInfo AppChooserWidgetApplicationActivatedSignalInfo where+    type HaskellCallbackType AppChooserWidgetApplicationActivatedSignalInfo = AppChooserWidgetApplicationActivatedCallback+    connectSignal _ = connectAppChooserWidgetApplicationActivated++data AppChooserWidgetApplicationSelectedSignalInfo+instance SignalInfo AppChooserWidgetApplicationSelectedSignalInfo where+    type HaskellCallbackType AppChooserWidgetApplicationSelectedSignalInfo = AppChooserWidgetApplicationSelectedCallback+    connectSignal _ = connectAppChooserWidgetApplicationSelected++data AppChooserWidgetPopulatePopupSignalInfo+instance SignalInfo AppChooserWidgetPopulatePopupSignalInfo where+    type HaskellCallbackType AppChooserWidgetPopulatePopupSignalInfo = AppChooserWidgetPopulatePopupCallback+    connectSignal _ = connectAppChooserWidgetPopulatePopup++type instance SignalList AppChooserWidget = AppChooserWidgetSignalList+type AppChooserWidgetSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("application-activated", AppChooserWidgetApplicationActivatedSignalInfo), '("application-selected", AppChooserWidgetApplicationSelectedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("populate-popup", AppChooserWidgetPopulatePopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AppChooserWidget::new+-- method type : Constructor+-- 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 : TInterface "Gtk" "AppChooserWidget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_new" gtk_app_chooser_widget_new :: +    CString ->                              -- content_type : TBasicType TUTF8+    IO (Ptr AppChooserWidget)+++appChooserWidgetNew ::+    (MonadIO m) =>+    T.Text ->                               -- content_type+    m AppChooserWidget+appChooserWidgetNew content_type = liftIO $ do+    content_type' <- textToCString content_type+    result <- gtk_app_chooser_widget_new content_type'+    checkUnexpectedReturnNULL "gtk_app_chooser_widget_new" result+    result' <- (newObject AppChooserWidget) result+    freeMem content_type'+    return result'++-- method AppChooserWidget::get_default_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_default_text" gtk_app_chooser_widget_get_default_text :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CString+++appChooserWidgetGetDefaultText ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m T.Text+appChooserWidgetGetDefaultText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_default_text _obj'+    checkUnexpectedReturnNULL "gtk_app_chooser_widget_get_default_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::get_show_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_show_all" gtk_app_chooser_widget_get_show_all :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CInt+++appChooserWidgetGetShowAll ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m Bool+appChooserWidgetGetShowAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_show_all _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::get_show_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_show_default" gtk_app_chooser_widget_get_show_default :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CInt+++appChooserWidgetGetShowDefault ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m Bool+appChooserWidgetGetShowDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_show_default _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::get_show_fallback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_show_fallback" gtk_app_chooser_widget_get_show_fallback :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CInt+++appChooserWidgetGetShowFallback ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m Bool+appChooserWidgetGetShowFallback _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_show_fallback _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::get_show_other+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_show_other" gtk_app_chooser_widget_get_show_other :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CInt+++appChooserWidgetGetShowOther ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m Bool+appChooserWidgetGetShowOther _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_show_other _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::get_show_recommended+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_app_chooser_widget_get_show_recommended" gtk_app_chooser_widget_get_show_recommended :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    IO CInt+++appChooserWidgetGetShowRecommended ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    m Bool+appChooserWidgetGetShowRecommended _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_app_chooser_widget_get_show_recommended _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AppChooserWidget::set_default_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_app_chooser_widget_set_default_text" gtk_app_chooser_widget_set_default_text :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++appChooserWidgetSetDefaultText ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+appChooserWidgetSetDefaultText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_app_chooser_widget_set_default_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method AppChooserWidget::set_show_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_widget_set_show_all" gtk_app_chooser_widget_set_show_all :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserWidgetSetShowAll ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserWidgetSetShowAll _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_widget_set_show_all _obj' setting'+    touchManagedPtr _obj+    return ()++-- method AppChooserWidget::set_show_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_widget_set_show_default" gtk_app_chooser_widget_set_show_default :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserWidgetSetShowDefault ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserWidgetSetShowDefault _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_widget_set_show_default _obj' setting'+    touchManagedPtr _obj+    return ()++-- method AppChooserWidget::set_show_fallback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_widget_set_show_fallback" gtk_app_chooser_widget_set_show_fallback :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserWidgetSetShowFallback ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserWidgetSetShowFallback _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_widget_set_show_fallback _obj' setting'+    touchManagedPtr _obj+    return ()++-- method AppChooserWidget::set_show_other+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_widget_set_show_other" gtk_app_chooser_widget_set_show_other :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserWidgetSetShowOther ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserWidgetSetShowOther _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_widget_set_show_other _obj' setting'+    touchManagedPtr _obj+    return ()++-- method AppChooserWidget::set_show_recommended+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AppChooserWidget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_app_chooser_widget_set_show_recommended" gtk_app_chooser_widget_set_show_recommended :: +    Ptr AppChooserWidget ->                 -- _obj : TInterface "Gtk" "AppChooserWidget"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++appChooserWidgetSetShowRecommended ::+    (MonadIO m, AppChooserWidgetK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+appChooserWidgetSetShowRecommended _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_app_chooser_widget_set_show_recommended _obj' setting'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/AppChooserWidget.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gtk.Objects.AppChooserWidget where++import Prelude ()+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 AppChooserWidget = AppChooserWidget (ForeignPtr AppChooserWidget)+instance GObject AppChooserWidget where+class GObject o => AppChooserWidgetK o+instance (GObject o, IsDescendantOf AppChooserWidget o) => AppChooserWidgetK o+data AppChooserWidgetDefaultTextPropertyInfo+data AppChooserWidgetShowAllPropertyInfo+data AppChooserWidgetShowDefaultPropertyInfo+data AppChooserWidgetShowFallbackPropertyInfo+data AppChooserWidgetShowOtherPropertyInfo+data AppChooserWidgetShowRecommendedPropertyInfo+data AppChooserWidgetApplicationActivatedSignalInfo+data AppChooserWidgetApplicationSelectedSignalInfo+data AppChooserWidgetPopulatePopupSignalInfo
+ GI/Gtk/Objects/Application.hs view
@@ -0,0 +1,1023 @@++{- |+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.Gtk.Objects.Application+    ( ++-- * Exported types+    Application(..)                         ,+    ApplicationK                            ,+    toApplication                           ,+    noApplication                           ,+++ -- * Methods+-- ** applicationAddAccelerator+    applicationAddAccelerator               ,+++-- ** applicationAddWindow+    applicationAddWindow                    ,+++-- ** applicationGetAccelsForAction+    applicationGetAccelsForAction           ,+++-- ** applicationGetActionsForAccel+    applicationGetActionsForAccel           ,+++-- ** applicationGetActiveWindow+    applicationGetActiveWindow              ,+++-- ** applicationGetAppMenu+    applicationGetAppMenu                   ,+++-- ** applicationGetMenuById+    applicationGetMenuById                  ,+++-- ** applicationGetMenubar+    applicationGetMenubar                   ,+++-- ** applicationGetWindowById+    applicationGetWindowById                ,+++-- ** applicationGetWindows+    applicationGetWindows                   ,+++-- ** applicationInhibit+    applicationInhibit                      ,+++-- ** applicationIsInhibited+    applicationIsInhibited                  ,+++-- ** applicationListActionDescriptions+    applicationListActionDescriptions       ,+++-- ** applicationNew+    applicationNew                          ,+++-- ** applicationPrefersAppMenu+    applicationPrefersAppMenu               ,+++-- ** applicationRemoveAccelerator+    applicationRemoveAccelerator            ,+++-- ** applicationRemoveWindow+    applicationRemoveWindow                 ,+++-- ** applicationSetAccelsForAction+    applicationSetAccelsForAction           ,+++-- ** applicationSetAppMenu+    applicationSetAppMenu                   ,+++-- ** applicationSetMenubar+    applicationSetMenubar                   ,+++-- ** applicationUninhibit+    applicationUninhibit                    ,+++++ -- * Properties+-- ** ActiveWindow+    ApplicationActiveWindowPropertyInfo     ,+    getApplicationActiveWindow              ,+++-- ** AppMenu+    ApplicationAppMenuPropertyInfo          ,+    constructApplicationAppMenu             ,+    getApplicationAppMenu                   ,+    setApplicationAppMenu                   ,+++-- ** Menubar+    ApplicationMenubarPropertyInfo          ,+    constructApplicationMenubar             ,+    getApplicationMenubar                   ,+    setApplicationMenubar                   ,+++-- ** RegisterSession+    ApplicationRegisterSessionPropertyInfo  ,+    constructApplicationRegisterSession     ,+    getApplicationRegisterSession           ,+    setApplicationRegisterSession           ,+++++ -- * Signals+-- ** WindowAdded+    ApplicationWindowAddedCallback          ,+    ApplicationWindowAddedCallbackC         ,+    ApplicationWindowAddedSignalInfo        ,+    afterApplicationWindowAdded             ,+    applicationWindowAddedCallbackWrapper   ,+    applicationWindowAddedClosure           ,+    mkApplicationWindowAddedCallback        ,+    noApplicationWindowAddedCallback        ,+    onApplicationWindowAdded                ,+++-- ** WindowRemoved+    ApplicationWindowRemovedCallback        ,+    ApplicationWindowRemovedCallbackC       ,+    ApplicationWindowRemovedSignalInfo      ,+    afterApplicationWindowRemoved           ,+    applicationWindowRemovedCallbackWrapper ,+    applicationWindowRemovedClosure         ,+    mkApplicationWindowRemovedCallback      ,+    noApplicationWindowRemovedCallback      ,+    onApplicationWindowRemoved              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype Application = Application (ForeignPtr Application)+foreign import ccall "gtk_application_get_type"+    c_gtk_application_get_type :: IO GType++type instance ParentTypes Application = ApplicationParentTypes+type ApplicationParentTypes = '[Gio.Application, GObject.Object, Gio.ActionGroup, Gio.ActionMap]++instance GObject Application where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_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::window-added+type ApplicationWindowAddedCallback =+    Window ->+    IO ()++noApplicationWindowAddedCallback :: Maybe ApplicationWindowAddedCallback+noApplicationWindowAddedCallback = Nothing++type ApplicationWindowAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Window ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationWindowAddedCallback :: ApplicationWindowAddedCallbackC -> IO (FunPtr ApplicationWindowAddedCallbackC)++applicationWindowAddedClosure :: ApplicationWindowAddedCallback -> IO Closure+applicationWindowAddedClosure cb = newCClosure =<< mkApplicationWindowAddedCallback wrapped+    where wrapped = applicationWindowAddedCallbackWrapper cb++applicationWindowAddedCallbackWrapper ::+    ApplicationWindowAddedCallback ->+    Ptr () ->+    Ptr Window ->+    Ptr () ->+    IO ()+applicationWindowAddedCallbackWrapper _cb _ window _ = do+    window' <- (newObject Window) window+    _cb  window'++onApplicationWindowAdded :: (GObject a, MonadIO m) => a -> ApplicationWindowAddedCallback -> m SignalHandlerId+onApplicationWindowAdded obj cb = liftIO $ connectApplicationWindowAdded obj cb SignalConnectBefore+afterApplicationWindowAdded :: (GObject a, MonadIO m) => a -> ApplicationWindowAddedCallback -> m SignalHandlerId+afterApplicationWindowAdded obj cb = connectApplicationWindowAdded obj cb SignalConnectAfter++connectApplicationWindowAdded :: (GObject a, MonadIO m) =>+                                 a -> ApplicationWindowAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationWindowAdded obj cb after = liftIO $ do+    cb' <- mkApplicationWindowAddedCallback (applicationWindowAddedCallbackWrapper cb)+    connectSignalFunPtr obj "window-added" cb' after++-- signal Application::window-removed+type ApplicationWindowRemovedCallback =+    Window ->+    IO ()++noApplicationWindowRemovedCallback :: Maybe ApplicationWindowRemovedCallback+noApplicationWindowRemovedCallback = Nothing++type ApplicationWindowRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Window ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkApplicationWindowRemovedCallback :: ApplicationWindowRemovedCallbackC -> IO (FunPtr ApplicationWindowRemovedCallbackC)++applicationWindowRemovedClosure :: ApplicationWindowRemovedCallback -> IO Closure+applicationWindowRemovedClosure cb = newCClosure =<< mkApplicationWindowRemovedCallback wrapped+    where wrapped = applicationWindowRemovedCallbackWrapper cb++applicationWindowRemovedCallbackWrapper ::+    ApplicationWindowRemovedCallback ->+    Ptr () ->+    Ptr Window ->+    Ptr () ->+    IO ()+applicationWindowRemovedCallbackWrapper _cb _ window _ = do+    window' <- (newObject Window) window+    _cb  window'++onApplicationWindowRemoved :: (GObject a, MonadIO m) => a -> ApplicationWindowRemovedCallback -> m SignalHandlerId+onApplicationWindowRemoved obj cb = liftIO $ connectApplicationWindowRemoved obj cb SignalConnectBefore+afterApplicationWindowRemoved :: (GObject a, MonadIO m) => a -> ApplicationWindowRemovedCallback -> m SignalHandlerId+afterApplicationWindowRemoved obj cb = connectApplicationWindowRemoved obj cb SignalConnectAfter++connectApplicationWindowRemoved :: (GObject a, MonadIO m) =>+                                   a -> ApplicationWindowRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectApplicationWindowRemoved obj cb after = liftIO $ do+    cb' <- mkApplicationWindowRemovedCallback (applicationWindowRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "window-removed" cb' after++-- VVV Prop "active-window"+   -- Type: TInterface "Gtk" "Window"+   -- Flags: [PropertyReadable]++getApplicationActiveWindow :: (MonadIO m, ApplicationK o) => o -> m Window+getApplicationActiveWindow obj = liftIO $ getObjectPropertyObject obj "active-window" Window++data ApplicationActiveWindowPropertyInfo+instance AttrInfo ApplicationActiveWindowPropertyInfo where+    type AttrAllowedOps ApplicationActiveWindowPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ApplicationActiveWindowPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ApplicationActiveWindowPropertyInfo = ApplicationK+    type AttrGetType ApplicationActiveWindowPropertyInfo = Window+    type AttrLabel ApplicationActiveWindowPropertyInfo = "Application::active-window"+    attrGet _ = getApplicationActiveWindow+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "app-menu"+   -- Type: TInterface "Gio" "MenuModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationAppMenu :: (MonadIO m, ApplicationK o) => o -> m Gio.MenuModel+getApplicationAppMenu obj = liftIO $ getObjectPropertyObject obj "app-menu" Gio.MenuModel++setApplicationAppMenu :: (MonadIO m, ApplicationK o, Gio.MenuModelK a) => o -> a -> m ()+setApplicationAppMenu obj val = liftIO $ setObjectPropertyObject obj "app-menu" val++constructApplicationAppMenu :: (Gio.MenuModelK a) => a -> IO ([Char], GValue)+constructApplicationAppMenu val = constructObjectPropertyObject "app-menu" val++data ApplicationAppMenuPropertyInfo+instance AttrInfo ApplicationAppMenuPropertyInfo where+    type AttrAllowedOps ApplicationAppMenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationAppMenuPropertyInfo = Gio.MenuModelK+    type AttrBaseTypeConstraint ApplicationAppMenuPropertyInfo = ApplicationK+    type AttrGetType ApplicationAppMenuPropertyInfo = Gio.MenuModel+    type AttrLabel ApplicationAppMenuPropertyInfo = "Application::app-menu"+    attrGet _ = getApplicationAppMenu+    attrSet _ = setApplicationAppMenu+    attrConstruct _ = constructApplicationAppMenu++-- VVV Prop "menubar"+   -- Type: TInterface "Gio" "MenuModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationMenubar :: (MonadIO m, ApplicationK o) => o -> m Gio.MenuModel+getApplicationMenubar obj = liftIO $ getObjectPropertyObject obj "menubar" Gio.MenuModel++setApplicationMenubar :: (MonadIO m, ApplicationK o, Gio.MenuModelK a) => o -> a -> m ()+setApplicationMenubar obj val = liftIO $ setObjectPropertyObject obj "menubar" val++constructApplicationMenubar :: (Gio.MenuModelK a) => a -> IO ([Char], GValue)+constructApplicationMenubar val = constructObjectPropertyObject "menubar" val++data ApplicationMenubarPropertyInfo+instance AttrInfo ApplicationMenubarPropertyInfo where+    type AttrAllowedOps ApplicationMenubarPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationMenubarPropertyInfo = Gio.MenuModelK+    type AttrBaseTypeConstraint ApplicationMenubarPropertyInfo = ApplicationK+    type AttrGetType ApplicationMenubarPropertyInfo = Gio.MenuModel+    type AttrLabel ApplicationMenubarPropertyInfo = "Application::menubar"+    attrGet _ = getApplicationMenubar+    attrSet _ = setApplicationMenubar+    attrConstruct _ = constructApplicationMenubar++-- VVV Prop "register-session"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getApplicationRegisterSession :: (MonadIO m, ApplicationK o) => o -> m Bool+getApplicationRegisterSession obj = liftIO $ getObjectPropertyBool obj "register-session"++setApplicationRegisterSession :: (MonadIO m, ApplicationK o) => o -> Bool -> m ()+setApplicationRegisterSession obj val = liftIO $ setObjectPropertyBool obj "register-session" val++constructApplicationRegisterSession :: Bool -> IO ([Char], GValue)+constructApplicationRegisterSession val = constructObjectPropertyBool "register-session" val++data ApplicationRegisterSessionPropertyInfo+instance AttrInfo ApplicationRegisterSessionPropertyInfo where+    type AttrAllowedOps ApplicationRegisterSessionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationRegisterSessionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ApplicationRegisterSessionPropertyInfo = ApplicationK+    type AttrGetType ApplicationRegisterSessionPropertyInfo = Bool+    type AttrLabel ApplicationRegisterSessionPropertyInfo = "Application::register-session"+    attrGet _ = getApplicationRegisterSession+    attrSet _ = setApplicationRegisterSession+    attrConstruct _ = constructApplicationRegisterSession++type instance AttributeList Application = ApplicationAttributeList+type ApplicationAttributeList = ('[ '("action-group", Gio.ApplicationActionGroupPropertyInfo), '("active-window", ApplicationActiveWindowPropertyInfo), '("app-menu", ApplicationAppMenuPropertyInfo), '("application-id", Gio.ApplicationApplicationIdPropertyInfo), '("flags", Gio.ApplicationFlagsPropertyInfo), '("inactivity-timeout", Gio.ApplicationInactivityTimeoutPropertyInfo), '("is-busy", Gio.ApplicationIsBusyPropertyInfo), '("is-registered", Gio.ApplicationIsRegisteredPropertyInfo), '("is-remote", Gio.ApplicationIsRemotePropertyInfo), '("menubar", ApplicationMenubarPropertyInfo), '("register-session", ApplicationRegisterSessionPropertyInfo), '("resource-base-path", Gio.ApplicationResourceBasePathPropertyInfo)] :: [(Symbol, *)])++data ApplicationWindowAddedSignalInfo+instance SignalInfo ApplicationWindowAddedSignalInfo where+    type HaskellCallbackType ApplicationWindowAddedSignalInfo = ApplicationWindowAddedCallback+    connectSignal _ = connectApplicationWindowAdded++data ApplicationWindowRemovedSignalInfo+instance SignalInfo ApplicationWindowRemovedSignalInfo where+    type HaskellCallbackType ApplicationWindowRemovedSignalInfo = ApplicationWindowRemovedCallback+    connectSignal _ = connectApplicationWindowRemoved++type instance SignalList Application = ApplicationSignalList+type ApplicationSignalList = ('[ '("action-added", Gio.ActionGroupActionAddedSignalInfo), '("action-enabled-changed", Gio.ActionGroupActionEnabledChangedSignalInfo), '("action-removed", Gio.ActionGroupActionRemovedSignalInfo), '("action-state-changed", Gio.ActionGroupActionStateChangedSignalInfo), '("activate", Gio.ApplicationActivateSignalInfo), '("command-line", Gio.ApplicationCommandLineSignalInfo), '("handle-local-options", Gio.ApplicationHandleLocalOptionsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("open", Gio.ApplicationOpenSignalInfo), '("shutdown", Gio.ApplicationShutdownSignalInfo), '("startup", Gio.ApplicationStartupSignalInfo), '("window-added", ApplicationWindowAddedSignalInfo), '("window-removed", ApplicationWindowRemovedSignalInfo), '("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 "Gtk" "Application"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_new" gtk_application_new :: +    CString ->                              -- application_id : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gio" "ApplicationFlags"+    IO (Ptr Application)+++applicationNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- application_id+    [Gio.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 <- gtk_application_new maybeApplication_id flags'+    checkUnexpectedReturnNULL "gtk_application_new" result+    result' <- (wrapObject Application) result+    freeMem maybeApplication_id+    return result'++-- method Application::add_accelerator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator", argType = TBasicType TUTF8, 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 "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accelerator", argType = TBasicType TUTF8, 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 "gtk_application_add_accelerator" gtk_application_add_accelerator :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- accelerator : TBasicType TUTF8+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameter : TVariant+    IO ()++{-# DEPRECATED applicationAddAccelerator ["(Since version 3.14)","Use gtk_application_set_accels_for_action() instead"]#-}+applicationAddAccelerator ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- accelerator+    T.Text ->                               -- action_name+    Maybe (GVariant) ->                     -- parameter+    m ()+applicationAddAccelerator _obj accelerator action_name parameter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    accelerator' <- textToCString accelerator+    action_name' <- textToCString action_name+    maybeParameter <- case parameter of+        Nothing -> return nullPtr+        Just jParameter -> do+            let jParameter' = unsafeManagedPtrGetPtr jParameter+            return jParameter'+    gtk_application_add_accelerator _obj' accelerator' action_name' maybeParameter+    touchManagedPtr _obj+    freeMem accelerator'+    freeMem action_name'+    return ()++-- method Application::add_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_add_window" gtk_application_add_window :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Ptr Window ->                           -- window : TInterface "Gtk" "Window"+    IO ()+++applicationAddWindow ::+    (MonadIO m, ApplicationK a, WindowK b) =>+    a ->                                    -- _obj+    b ->                                    -- window+    m ()+applicationAddWindow _obj window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let window' = unsafeManagedPtrCastPtr window+    gtk_application_add_window _obj' window'+    touchManagedPtr _obj+    touchManagedPtr window+    return ()++-- method Application::get_accels_for_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action_name", 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 "gtk_application_get_accels_for_action" gtk_application_get_accels_for_action :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- detailed_action_name : TBasicType TUTF8+    IO (Ptr CString)+++applicationGetAccelsForAction ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- detailed_action_name+    m [T.Text]+applicationGetAccelsForAction _obj detailed_action_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    detailed_action_name' <- textToCString detailed_action_name+    result <- gtk_application_get_accels_for_action _obj' detailed_action_name'+    checkUnexpectedReturnNULL "gtk_application_get_accels_for_action" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem detailed_action_name'+    return result'++-- method Application::get_actions_for_accel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel", 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 "gtk_application_get_actions_for_accel" gtk_application_get_actions_for_accel :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- accel : TBasicType TUTF8+    IO (Ptr CString)+++applicationGetActionsForAccel ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- accel+    m [T.Text]+applicationGetActionsForAccel _obj accel = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    accel' <- textToCString accel+    result <- gtk_application_get_actions_for_accel _obj' accel'+    checkUnexpectedReturnNULL "gtk_application_get_actions_for_accel" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    freeMem accel'+    return result'++-- method Application::get_active_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_active_window" gtk_application_get_active_window :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO (Ptr Window)+++applicationGetActiveWindow ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Window+applicationGetActiveWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_get_active_window _obj'+    checkUnexpectedReturnNULL "gtk_application_get_active_window" result+    result' <- (newObject Window) result+    touchManagedPtr _obj+    return result'++-- method Application::get_app_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_app_menu" gtk_application_get_app_menu :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO (Ptr Gio.MenuModel)+++applicationGetAppMenu ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Gio.MenuModel+applicationGetAppMenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_get_app_menu _obj'+    checkUnexpectedReturnNULL "gtk_application_get_app_menu" result+    result' <- (newObject Gio.MenuModel) result+    touchManagedPtr _obj+    return result'++-- method Application::get_menu_by_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "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 "Gtk" "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 : TInterface "Gio" "Menu"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_menu_by_id" gtk_application_get_menu_by_id :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- id : TBasicType TUTF8+    IO (Ptr Gio.Menu)+++applicationGetMenuById ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- id+    m Gio.Menu+applicationGetMenuById _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    id' <- textToCString id+    result <- gtk_application_get_menu_by_id _obj' id'+    checkUnexpectedReturnNULL "gtk_application_get_menu_by_id" result+    result' <- (newObject Gio.Menu) result+    touchManagedPtr _obj+    freeMem id'+    return result'++-- method Application::get_menubar+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_menubar" gtk_application_get_menubar :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO (Ptr Gio.MenuModel)+++applicationGetMenubar ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Gio.MenuModel+applicationGetMenubar _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_get_menubar _obj'+    checkUnexpectedReturnNULL "gtk_application_get_menubar" result+    result' <- (newObject Gio.MenuModel) result+    touchManagedPtr _obj+    return result'++-- method Application::get_window_by_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_window_by_id" gtk_application_get_window_by_id :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Word32 ->                               -- id : TBasicType TUInt32+    IO (Ptr Window)+++applicationGetWindowById ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- id+    m Window+applicationGetWindowById _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_get_window_by_id _obj' id+    checkUnexpectedReturnNULL "gtk_application_get_window_by_id" result+    result' <- (newObject Window) result+    touchManagedPtr _obj+    return result'++-- method Application::get_windows+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "Window")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_get_windows" gtk_application_get_windows :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO (Ptr (GList (Ptr Window)))+++applicationGetWindows ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m [Window]+applicationGetWindows _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_get_windows _obj'+    checkUnexpectedReturnNULL "gtk_application_get_windows" result+    result' <- unpackGList result+    result'' <- mapM (newObject Window) result'+    touchManagedPtr _obj+    return result''++-- method Application::inhibit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "ApplicationInhibitFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reason", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "ApplicationInhibitFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reason", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_inhibit" gtk_application_inhibit :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Ptr Window ->                           -- window : TInterface "Gtk" "Window"+    CUInt ->                                -- flags : TInterface "Gtk" "ApplicationInhibitFlags"+    CString ->                              -- reason : TBasicType TUTF8+    IO Word32+++applicationInhibit ::+    (MonadIO m, ApplicationK a, WindowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- window+    [ApplicationInhibitFlags] ->            -- flags+    Maybe (T.Text) ->                       -- reason+    m Word32+applicationInhibit _obj window flags reason = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWindow <- case window of+        Nothing -> return nullPtr+        Just jWindow -> do+            let jWindow' = unsafeManagedPtrCastPtr jWindow+            return jWindow'+    let flags' = gflagsToWord flags+    maybeReason <- case reason of+        Nothing -> return nullPtr+        Just jReason -> do+            jReason' <- textToCString jReason+            return jReason'+    result <- gtk_application_inhibit _obj' maybeWindow flags' maybeReason+    touchManagedPtr _obj+    whenJust window touchManagedPtr+    freeMem maybeReason+    return result++-- method Application::is_inhibited+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "ApplicationInhibitFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "ApplicationInhibitFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_is_inhibited" gtk_application_is_inhibited :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CUInt ->                                -- flags : TInterface "Gtk" "ApplicationInhibitFlags"+    IO CInt+++applicationIsInhibited ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    [ApplicationInhibitFlags] ->            -- flags+    m Bool+applicationIsInhibited _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    result <- gtk_application_is_inhibited _obj' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Application::list_action_descriptions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", 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 "gtk_application_list_action_descriptions" gtk_application_list_action_descriptions :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO (Ptr CString)+++applicationListActionDescriptions ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m [T.Text]+applicationListActionDescriptions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_list_action_descriptions _obj'+    checkUnexpectedReturnNULL "gtk_application_list_action_descriptions" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Application::prefers_app_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_prefers_app_menu" gtk_application_prefers_app_menu :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    IO CInt+++applicationPrefersAppMenu ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    m Bool+applicationPrefersAppMenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_prefers_app_menu _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Application::remove_accelerator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", 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 "Gtk" "Application", 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 "gtk_application_remove_accelerator" gtk_application_remove_accelerator :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- action_name : TBasicType TUTF8+    Ptr GVariant ->                         -- parameter : TVariant+    IO ()++{-# DEPRECATED applicationRemoveAccelerator ["(Since version 3.14)","Use gtk_application_set_accels_for_action() instead"]#-}+applicationRemoveAccelerator ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- action_name+    Maybe (GVariant) ->                     -- parameter+    m ()+applicationRemoveAccelerator _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'+    gtk_application_remove_accelerator _obj' action_name' maybeParameter+    touchManagedPtr _obj+    freeMem action_name'+    return ()++-- method Application::remove_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_remove_window" gtk_application_remove_window :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Ptr Window ->                           -- window : TInterface "Gtk" "Window"+    IO ()+++applicationRemoveWindow ::+    (MonadIO m, ApplicationK a, WindowK b) =>+    a ->                                    -- _obj+    b ->                                    -- window+    m ()+applicationRemoveWindow _obj window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let window' = unsafeManagedPtrCastPtr window+    gtk_application_remove_window _obj' window'+    touchManagedPtr _obj+    touchManagedPtr window+    return ()++-- method Application::set_accels_for_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accels", 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 "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detailed_action_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accels", argType = TCArray True (-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 "gtk_application_set_accels_for_action" gtk_application_set_accels_for_action :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    CString ->                              -- detailed_action_name : TBasicType TUTF8+    Ptr CString ->                          -- accels : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++applicationSetAccelsForAction ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- detailed_action_name+    [T.Text] ->                             -- accels+    m ()+applicationSetAccelsForAction _obj detailed_action_name accels = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    detailed_action_name' <- textToCString detailed_action_name+    accels' <- packZeroTerminatedUTF8CArray accels+    gtk_application_set_accels_for_action _obj' detailed_action_name' accels'+    touchManagedPtr _obj+    freeMem detailed_action_name'+    mapZeroTerminatedCArray freeMem accels'+    freeMem accels'+    return ()++-- method Application::set_app_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "app_menu", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "app_menu", 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 "gtk_application_set_app_menu" gtk_application_set_app_menu :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Ptr Gio.MenuModel ->                    -- app_menu : TInterface "Gio" "MenuModel"+    IO ()+++applicationSetAppMenu ::+    (MonadIO m, ApplicationK a, Gio.MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- app_menu+    m ()+applicationSetAppMenu _obj app_menu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeApp_menu <- case app_menu of+        Nothing -> return nullPtr+        Just jApp_menu -> do+            let jApp_menu' = unsafeManagedPtrCastPtr jApp_menu+            return jApp_menu'+    gtk_application_set_app_menu _obj' maybeApp_menu+    touchManagedPtr _obj+    whenJust app_menu touchManagedPtr+    return ()++-- method Application::set_menubar+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menubar", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menubar", 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 "gtk_application_set_menubar" gtk_application_set_menubar :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Ptr Gio.MenuModel ->                    -- menubar : TInterface "Gio" "MenuModel"+    IO ()+++applicationSetMenubar ::+    (MonadIO m, ApplicationK a, Gio.MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- menubar+    m ()+applicationSetMenubar _obj menubar = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeMenubar <- case menubar of+        Nothing -> return nullPtr+        Just jMenubar -> do+            let jMenubar' = unsafeManagedPtrCastPtr jMenubar+            return jMenubar'+    gtk_application_set_menubar _obj' maybeMenubar+    touchManagedPtr _obj+    whenJust menubar touchManagedPtr+    return ()++-- method Application::uninhibit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cookie", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cookie", 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 "gtk_application_uninhibit" gtk_application_uninhibit :: +    Ptr Application ->                      -- _obj : TInterface "Gtk" "Application"+    Word32 ->                               -- cookie : TBasicType TUInt32+    IO ()+++applicationUninhibit ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- cookie+    m ()+applicationUninhibit _obj cookie = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_application_uninhibit _obj' cookie+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Application.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.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 ApplicationActiveWindowPropertyInfo+data ApplicationAppMenuPropertyInfo+data ApplicationMenubarPropertyInfo+data ApplicationRegisterSessionPropertyInfo+data ApplicationWindowAddedSignalInfo+data ApplicationWindowRemovedSignalInfo
+ GI/Gtk/Objects/ApplicationWindow.hs view
@@ -0,0 +1,215 @@++{- |+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.Gtk.Objects.ApplicationWindow+    ( ++-- * Exported types+    ApplicationWindow(..)                   ,+    ApplicationWindowK                      ,+    toApplicationWindow                     ,+    noApplicationWindow                     ,+++ -- * Methods+-- ** applicationWindowGetId+    applicationWindowGetId                  ,+++-- ** applicationWindowGetShowMenubar+    applicationWindowGetShowMenubar         ,+++-- ** applicationWindowNew+    applicationWindowNew                    ,+++-- ** applicationWindowSetShowMenubar+    applicationWindowSetShowMenubar         ,+++++ -- * Properties+-- ** ShowMenubar+    ApplicationWindowShowMenubarPropertyInfo,+    constructApplicationWindowShowMenubar   ,+    getApplicationWindowShowMenubar         ,+    setApplicationWindowShowMenubar         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype ApplicationWindow = ApplicationWindow (ForeignPtr ApplicationWindow)+foreign import ccall "gtk_application_window_get_type"+    c_gtk_application_window_get_type :: IO GType++type instance ParentTypes ApplicationWindow = ApplicationWindowParentTypes+type ApplicationWindowParentTypes = '[Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Gio.ActionGroup, Gio.ActionMap, Buildable]++instance GObject ApplicationWindow where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_application_window_get_type+    ++class GObject o => ApplicationWindowK o+instance (GObject o, IsDescendantOf ApplicationWindow o) => ApplicationWindowK o++toApplicationWindow :: ApplicationWindowK o => o -> IO ApplicationWindow+toApplicationWindow = unsafeCastTo ApplicationWindow++noApplicationWindow :: Maybe ApplicationWindow+noApplicationWindow = Nothing++-- VVV Prop "show-menubar"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getApplicationWindowShowMenubar :: (MonadIO m, ApplicationWindowK o) => o -> m Bool+getApplicationWindowShowMenubar obj = liftIO $ getObjectPropertyBool obj "show-menubar"++setApplicationWindowShowMenubar :: (MonadIO m, ApplicationWindowK o) => o -> Bool -> m ()+setApplicationWindowShowMenubar obj val = liftIO $ setObjectPropertyBool obj "show-menubar" val++constructApplicationWindowShowMenubar :: Bool -> IO ([Char], GValue)+constructApplicationWindowShowMenubar val = constructObjectPropertyBool "show-menubar" val++data ApplicationWindowShowMenubarPropertyInfo+instance AttrInfo ApplicationWindowShowMenubarPropertyInfo where+    type AttrAllowedOps ApplicationWindowShowMenubarPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ApplicationWindowShowMenubarPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ApplicationWindowShowMenubarPropertyInfo = ApplicationWindowK+    type AttrGetType ApplicationWindowShowMenubarPropertyInfo = Bool+    type AttrLabel ApplicationWindowShowMenubarPropertyInfo = "ApplicationWindow::show-menubar"+    attrGet _ = getApplicationWindowShowMenubar+    attrSet _ = setApplicationWindowShowMenubar+    attrConstruct _ = constructApplicationWindowShowMenubar++type instance AttributeList ApplicationWindow = ApplicationWindowAttributeList+type ApplicationWindowAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-menubar", ApplicationWindowShowMenubarPropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ApplicationWindow = ApplicationWindowSignalList+type ApplicationWindowSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("action-added", Gio.ActionGroupActionAddedSignalInfo), '("action-enabled-changed", Gio.ActionGroupActionEnabledChangedSignalInfo), '("action-removed", Gio.ActionGroupActionRemovedSignalInfo), '("action-state-changed", Gio.ActionGroupActionStateChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ApplicationWindow::new+-- method type : Constructor+-- Args : [Arg {argName = "application", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "application", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ApplicationWindow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_window_new" gtk_application_window_new :: +    Ptr Application ->                      -- application : TInterface "Gtk" "Application"+    IO (Ptr ApplicationWindow)+++applicationWindowNew ::+    (MonadIO m, ApplicationK a) =>+    a ->                                    -- application+    m ApplicationWindow+applicationWindowNew application = liftIO $ do+    let application' = unsafeManagedPtrCastPtr application+    result <- gtk_application_window_new application'+    checkUnexpectedReturnNULL "gtk_application_window_new" result+    result' <- (newObject ApplicationWindow) result+    touchManagedPtr application+    return result'++-- method ApplicationWindow::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_window_get_id" gtk_application_window_get_id :: +    Ptr ApplicationWindow ->                -- _obj : TInterface "Gtk" "ApplicationWindow"+    IO Word32+++applicationWindowGetId ::+    (MonadIO m, ApplicationWindowK a) =>+    a ->                                    -- _obj+    m Word32+applicationWindowGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_window_get_id _obj'+    touchManagedPtr _obj+    return result++-- method ApplicationWindow::get_show_menubar+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_application_window_get_show_menubar" gtk_application_window_get_show_menubar :: +    Ptr ApplicationWindow ->                -- _obj : TInterface "Gtk" "ApplicationWindow"+    IO CInt+++applicationWindowGetShowMenubar ::+    (MonadIO m, ApplicationWindowK a) =>+    a ->                                    -- _obj+    m Bool+applicationWindowGetShowMenubar _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_application_window_get_show_menubar _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ApplicationWindow::set_show_menubar+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_menubar", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ApplicationWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_menubar", 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 "gtk_application_window_set_show_menubar" gtk_application_window_set_show_menubar :: +    Ptr ApplicationWindow ->                -- _obj : TInterface "Gtk" "ApplicationWindow"+    CInt ->                                 -- show_menubar : TBasicType TBoolean+    IO ()+++applicationWindowSetShowMenubar ::+    (MonadIO m, ApplicationWindowK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_menubar+    m ()+applicationWindowSetShowMenubar _obj show_menubar = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_menubar' = (fromIntegral . fromEnum) show_menubar+    gtk_application_window_set_show_menubar _obj' show_menubar'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ApplicationWindow.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.ApplicationWindow where++import Prelude ()+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 ApplicationWindow = ApplicationWindow (ForeignPtr ApplicationWindow)+instance GObject ApplicationWindow where+class GObject o => ApplicationWindowK o+instance (GObject o, IsDescendantOf ApplicationWindow o) => ApplicationWindowK o+data ApplicationWindowShowMenubarPropertyInfo
+ GI/Gtk/Objects/Arrow.hs view
@@ -0,0 +1,193 @@++{- |+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.Gtk.Objects.Arrow+    ( ++-- * Exported types+    Arrow(..)                               ,+    ArrowK                                  ,+    toArrow                                 ,+    noArrow                                 ,+++ -- * Methods+-- ** arrowNew+    arrowNew                                ,+++-- ** arrowSet+    arrowSet                                ,+++++ -- * Properties+-- ** ArrowType+    ArrowArrowTypePropertyInfo              ,+    constructArrowArrowType                 ,+    getArrowArrowType                       ,+    setArrowArrowType                       ,+++-- ** ShadowType+    ArrowShadowTypePropertyInfo             ,+    constructArrowShadowType                ,+    getArrowShadowType                      ,+    setArrowShadowType                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Arrow = Arrow (ForeignPtr Arrow)+foreign import ccall "gtk_arrow_get_type"+    c_gtk_arrow_get_type :: IO GType++type instance ParentTypes Arrow = ArrowParentTypes+type ArrowParentTypes = '[Misc, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Arrow where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_arrow_get_type+    ++class GObject o => ArrowK o+instance (GObject o, IsDescendantOf Arrow o) => ArrowK o++toArrow :: ArrowK o => o -> IO Arrow+toArrow = unsafeCastTo Arrow++noArrow :: Maybe Arrow+noArrow = Nothing++-- VVV Prop "arrow-type"+   -- Type: TInterface "Gtk" "ArrowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getArrowArrowType :: (MonadIO m, ArrowK o) => o -> m ArrowType+getArrowArrowType obj = liftIO $ getObjectPropertyEnum obj "arrow-type"++setArrowArrowType :: (MonadIO m, ArrowK o) => o -> ArrowType -> m ()+setArrowArrowType obj val = liftIO $ setObjectPropertyEnum obj "arrow-type" val++constructArrowArrowType :: ArrowType -> IO ([Char], GValue)+constructArrowArrowType val = constructObjectPropertyEnum "arrow-type" val++data ArrowArrowTypePropertyInfo+instance AttrInfo ArrowArrowTypePropertyInfo where+    type AttrAllowedOps ArrowArrowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ArrowArrowTypePropertyInfo = (~) ArrowType+    type AttrBaseTypeConstraint ArrowArrowTypePropertyInfo = ArrowK+    type AttrGetType ArrowArrowTypePropertyInfo = ArrowType+    type AttrLabel ArrowArrowTypePropertyInfo = "Arrow::arrow-type"+    attrGet _ = getArrowArrowType+    attrSet _ = setArrowArrowType+    attrConstruct _ = constructArrowArrowType++-- VVV Prop "shadow-type"+   -- Type: TInterface "Gtk" "ShadowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getArrowShadowType :: (MonadIO m, ArrowK o) => o -> m ShadowType+getArrowShadowType obj = liftIO $ getObjectPropertyEnum obj "shadow-type"++setArrowShadowType :: (MonadIO m, ArrowK o) => o -> ShadowType -> m ()+setArrowShadowType obj val = liftIO $ setObjectPropertyEnum obj "shadow-type" val++constructArrowShadowType :: ShadowType -> IO ([Char], GValue)+constructArrowShadowType val = constructObjectPropertyEnum "shadow-type" val++data ArrowShadowTypePropertyInfo+instance AttrInfo ArrowShadowTypePropertyInfo where+    type AttrAllowedOps ArrowShadowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ArrowShadowTypePropertyInfo = (~) ShadowType+    type AttrBaseTypeConstraint ArrowShadowTypePropertyInfo = ArrowK+    type AttrGetType ArrowShadowTypePropertyInfo = ShadowType+    type AttrLabel ArrowShadowTypePropertyInfo = "Arrow::shadow-type"+    attrGet _ = getArrowShadowType+    attrSet _ = setArrowShadowType+    attrConstruct _ = constructArrowShadowType++type instance AttributeList Arrow = ArrowAttributeList+type ArrowAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("arrow-type", ArrowArrowTypePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", ArrowShadowTypePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", MiscXalignPropertyInfo), '("xpad", MiscXpadPropertyInfo), '("yalign", MiscYalignPropertyInfo), '("ypad", MiscYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Arrow = ArrowSignalList+type ArrowSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Arrow::new+-- method type : Constructor+-- Args : [Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Arrow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_arrow_new" gtk_arrow_new :: +    CUInt ->                                -- arrow_type : TInterface "Gtk" "ArrowType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    IO (Ptr Arrow)++{-# DEPRECATED arrowNew ["(Since version 3.14)","Use a #GtkImage with a suitable icon."]#-}+arrowNew ::+    (MonadIO m) =>+    ArrowType ->                            -- arrow_type+    ShadowType ->                           -- shadow_type+    m Arrow+arrowNew arrow_type shadow_type = liftIO $ do+    let arrow_type' = (fromIntegral . fromEnum) arrow_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    result <- gtk_arrow_new arrow_type' shadow_type'+    checkUnexpectedReturnNULL "gtk_arrow_new" result+    result' <- (newObject Arrow) result+    return result'++-- method Arrow::set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Arrow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Arrow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "arrow_type", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shadow_type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_arrow_set" gtk_arrow_set :: +    Ptr Arrow ->                            -- _obj : TInterface "Gtk" "Arrow"+    CUInt ->                                -- arrow_type : TInterface "Gtk" "ArrowType"+    CUInt ->                                -- shadow_type : TInterface "Gtk" "ShadowType"+    IO ()++{-# DEPRECATED arrowSet ["(Since version 3.14)","Use a #GtkImage with a suitable icon."]#-}+arrowSet ::+    (MonadIO m, ArrowK a) =>+    a ->                                    -- _obj+    ArrowType ->                            -- arrow_type+    ShadowType ->                           -- shadow_type+    m ()+arrowSet _obj arrow_type shadow_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let arrow_type' = (fromIntegral . fromEnum) arrow_type+    let shadow_type' = (fromIntegral . fromEnum) shadow_type+    gtk_arrow_set _obj' arrow_type' shadow_type'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Arrow.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.Arrow where++import Prelude ()+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 Arrow = Arrow (ForeignPtr Arrow)+instance GObject Arrow where+class GObject o => ArrowK o+instance (GObject o, IsDescendantOf Arrow o) => ArrowK o+data ArrowArrowTypePropertyInfo+data ArrowShadowTypePropertyInfo
+ GI/Gtk/Objects/ArrowAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ArrowAccessible+    ( ++-- * Exported types+    ArrowAccessible(..)                     ,+    ArrowAccessibleK                        ,+    toArrowAccessible                       ,+    noArrowAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ArrowAccessible = ArrowAccessible (ForeignPtr ArrowAccessible)+foreign import ccall "gtk_arrow_accessible_get_type"+    c_gtk_arrow_accessible_get_type :: IO GType++type instance ParentTypes ArrowAccessible = ArrowAccessibleParentTypes+type ArrowAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Image]++instance GObject ArrowAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_arrow_accessible_get_type+    ++class GObject o => ArrowAccessibleK o+instance (GObject o, IsDescendantOf ArrowAccessible o) => ArrowAccessibleK o++toArrowAccessible :: ArrowAccessibleK o => o -> IO ArrowAccessible+toArrowAccessible = unsafeCastTo ArrowAccessible++noArrowAccessible :: Maybe ArrowAccessible+noArrowAccessible = Nothing++type instance AttributeList ArrowAccessible = ArrowAccessibleAttributeList+type ArrowAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ArrowAccessible = ArrowAccessibleSignalList+type ArrowAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ArrowAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ArrowAccessible where++import Prelude ()+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 ArrowAccessible = ArrowAccessible (ForeignPtr ArrowAccessible)+instance GObject ArrowAccessible where+class GObject o => ArrowAccessibleK o+instance (GObject o, IsDescendantOf ArrowAccessible o) => ArrowAccessibleK o
+ GI/Gtk/Objects/AspectFrame.hs view
@@ -0,0 +1,275 @@++{- |+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.Gtk.Objects.AspectFrame+    ( ++-- * Exported types+    AspectFrame(..)                         ,+    AspectFrameK                            ,+    toAspectFrame                           ,+    noAspectFrame                           ,+++ -- * Methods+-- ** aspectFrameNew+    aspectFrameNew                          ,+++-- ** aspectFrameSet+    aspectFrameSet                          ,+++++ -- * Properties+-- ** ObeyChild+    AspectFrameObeyChildPropertyInfo        ,+    constructAspectFrameObeyChild           ,+    getAspectFrameObeyChild                 ,+    setAspectFrameObeyChild                 ,+++-- ** Ratio+    AspectFrameRatioPropertyInfo            ,+    constructAspectFrameRatio               ,+    getAspectFrameRatio                     ,+    setAspectFrameRatio                     ,+++-- ** Xalign+    AspectFrameXalignPropertyInfo           ,+    constructAspectFrameXalign              ,+    getAspectFrameXalign                    ,+    setAspectFrameXalign                    ,+++-- ** Yalign+    AspectFrameYalignPropertyInfo           ,+    constructAspectFrameYalign              ,+    getAspectFrameYalign                    ,+    setAspectFrameYalign                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype AspectFrame = AspectFrame (ForeignPtr AspectFrame)+foreign import ccall "gtk_aspect_frame_get_type"+    c_gtk_aspect_frame_get_type :: IO GType++type instance ParentTypes AspectFrame = AspectFrameParentTypes+type AspectFrameParentTypes = '[Frame, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject AspectFrame where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_aspect_frame_get_type+    ++class GObject o => AspectFrameK o+instance (GObject o, IsDescendantOf AspectFrame o) => AspectFrameK o++toAspectFrame :: AspectFrameK o => o -> IO AspectFrame+toAspectFrame = unsafeCastTo AspectFrame++noAspectFrame :: Maybe AspectFrame+noAspectFrame = Nothing++-- VVV Prop "obey-child"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getAspectFrameObeyChild :: (MonadIO m, AspectFrameK o) => o -> m Bool+getAspectFrameObeyChild obj = liftIO $ getObjectPropertyBool obj "obey-child"++setAspectFrameObeyChild :: (MonadIO m, AspectFrameK o) => o -> Bool -> m ()+setAspectFrameObeyChild obj val = liftIO $ setObjectPropertyBool obj "obey-child" val++constructAspectFrameObeyChild :: Bool -> IO ([Char], GValue)+constructAspectFrameObeyChild val = constructObjectPropertyBool "obey-child" val++data AspectFrameObeyChildPropertyInfo+instance AttrInfo AspectFrameObeyChildPropertyInfo where+    type AttrAllowedOps AspectFrameObeyChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AspectFrameObeyChildPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint AspectFrameObeyChildPropertyInfo = AspectFrameK+    type AttrGetType AspectFrameObeyChildPropertyInfo = Bool+    type AttrLabel AspectFrameObeyChildPropertyInfo = "AspectFrame::obey-child"+    attrGet _ = getAspectFrameObeyChild+    attrSet _ = setAspectFrameObeyChild+    attrConstruct _ = constructAspectFrameObeyChild++-- VVV Prop "ratio"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAspectFrameRatio :: (MonadIO m, AspectFrameK o) => o -> m Float+getAspectFrameRatio obj = liftIO $ getObjectPropertyFloat obj "ratio"++setAspectFrameRatio :: (MonadIO m, AspectFrameK o) => o -> Float -> m ()+setAspectFrameRatio obj val = liftIO $ setObjectPropertyFloat obj "ratio" val++constructAspectFrameRatio :: Float -> IO ([Char], GValue)+constructAspectFrameRatio val = constructObjectPropertyFloat "ratio" val++data AspectFrameRatioPropertyInfo+instance AttrInfo AspectFrameRatioPropertyInfo where+    type AttrAllowedOps AspectFrameRatioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AspectFrameRatioPropertyInfo = (~) Float+    type AttrBaseTypeConstraint AspectFrameRatioPropertyInfo = AspectFrameK+    type AttrGetType AspectFrameRatioPropertyInfo = Float+    type AttrLabel AspectFrameRatioPropertyInfo = "AspectFrame::ratio"+    attrGet _ = getAspectFrameRatio+    attrSet _ = setAspectFrameRatio+    attrConstruct _ = constructAspectFrameRatio++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAspectFrameXalign :: (MonadIO m, AspectFrameK o) => o -> m Float+getAspectFrameXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setAspectFrameXalign :: (MonadIO m, AspectFrameK o) => o -> Float -> m ()+setAspectFrameXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructAspectFrameXalign :: Float -> IO ([Char], GValue)+constructAspectFrameXalign val = constructObjectPropertyFloat "xalign" val++data AspectFrameXalignPropertyInfo+instance AttrInfo AspectFrameXalignPropertyInfo where+    type AttrAllowedOps AspectFrameXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AspectFrameXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint AspectFrameXalignPropertyInfo = AspectFrameK+    type AttrGetType AspectFrameXalignPropertyInfo = Float+    type AttrLabel AspectFrameXalignPropertyInfo = "AspectFrame::xalign"+    attrGet _ = getAspectFrameXalign+    attrSet _ = setAspectFrameXalign+    attrConstruct _ = constructAspectFrameXalign++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getAspectFrameYalign :: (MonadIO m, AspectFrameK o) => o -> m Float+getAspectFrameYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setAspectFrameYalign :: (MonadIO m, AspectFrameK o) => o -> Float -> m ()+setAspectFrameYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructAspectFrameYalign :: Float -> IO ([Char], GValue)+constructAspectFrameYalign val = constructObjectPropertyFloat "yalign" val++data AspectFrameYalignPropertyInfo+instance AttrInfo AspectFrameYalignPropertyInfo where+    type AttrAllowedOps AspectFrameYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AspectFrameYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint AspectFrameYalignPropertyInfo = AspectFrameK+    type AttrGetType AspectFrameYalignPropertyInfo = Float+    type AttrLabel AspectFrameYalignPropertyInfo = "AspectFrame::yalign"+    attrGet _ = getAspectFrameYalign+    attrSet _ = setAspectFrameYalign+    attrConstruct _ = constructAspectFrameYalign++type instance AttributeList AspectFrame = AspectFrameAttributeList+type AspectFrameAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", FrameLabelPropertyInfo), '("label-widget", FrameLabelWidgetPropertyInfo), '("label-xalign", FrameLabelXalignPropertyInfo), '("label-yalign", FrameLabelYalignPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("obey-child", AspectFrameObeyChildPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("ratio", AspectFrameRatioPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", FrameShadowTypePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", AspectFrameXalignPropertyInfo), '("yalign", AspectFrameYalignPropertyInfo)] :: [(Symbol, *)])++type instance SignalList AspectFrame = AspectFrameSignalList+type AspectFrameSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AspectFrame::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 = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ratio", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "obey_child", argType = TBasicType TBoolean, 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 = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ratio", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "obey_child", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AspectFrame"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_aspect_frame_new" gtk_aspect_frame_new :: +    CString ->                              -- label : TBasicType TUTF8+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    CFloat ->                               -- ratio : TBasicType TFloat+    CInt ->                                 -- obey_child : TBasicType TBoolean+    IO (Ptr AspectFrame)+++aspectFrameNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- label+    Float ->                                -- xalign+    Float ->                                -- yalign+    Float ->                                -- ratio+    Bool ->                                 -- obey_child+    m AspectFrame+aspectFrameNew label xalign yalign ratio obey_child = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    let ratio' = realToFrac ratio+    let obey_child' = (fromIntegral . fromEnum) obey_child+    result <- gtk_aspect_frame_new maybeLabel xalign' yalign' ratio' obey_child'+    checkUnexpectedReturnNULL "gtk_aspect_frame_new" result+    result' <- (newObject AspectFrame) result+    freeMem maybeLabel+    return result'++-- method AspectFrame::set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "AspectFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ratio", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "obey_child", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "AspectFrame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ratio", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "obey_child", 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 "gtk_aspect_frame_set" gtk_aspect_frame_set :: +    Ptr AspectFrame ->                      -- _obj : TInterface "Gtk" "AspectFrame"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    CFloat ->                               -- ratio : TBasicType TFloat+    CInt ->                                 -- obey_child : TBasicType TBoolean+    IO ()+++aspectFrameSet ::+    (MonadIO m, AspectFrameK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    Float ->                                -- ratio+    Bool ->                                 -- obey_child+    m ()+aspectFrameSet _obj xalign yalign ratio obey_child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    let ratio' = realToFrac ratio+    let obey_child' = (fromIntegral . fromEnum) obey_child+    gtk_aspect_frame_set _obj' xalign' yalign' ratio' obey_child'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/AspectFrame.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.AspectFrame where++import Prelude ()+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 AspectFrame = AspectFrame (ForeignPtr AspectFrame)+instance GObject AspectFrame where+class GObject o => AspectFrameK o+instance (GObject o, IsDescendantOf AspectFrame o) => AspectFrameK o+data AspectFrameObeyChildPropertyInfo+data AspectFrameRatioPropertyInfo+data AspectFrameXalignPropertyInfo+data AspectFrameYalignPropertyInfo
+ GI/Gtk/Objects/Assistant.hs view
@@ -0,0 +1,1285 @@++{- |+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.Gtk.Objects.Assistant+    ( ++-- * Exported types+    Assistant(..)                           ,+    AssistantK                              ,+    toAssistant                             ,+    noAssistant                             ,+++ -- * Methods+-- ** assistantAddActionWidget+    assistantAddActionWidget                ,+++-- ** assistantAppendPage+    assistantAppendPage                     ,+++-- ** assistantCommit+    assistantCommit                         ,+++-- ** assistantGetCurrentPage+    assistantGetCurrentPage                 ,+++-- ** assistantGetNPages+    assistantGetNPages                      ,+++-- ** assistantGetNthPage+    assistantGetNthPage                     ,+++-- ** assistantGetPageComplete+    assistantGetPageComplete                ,+++-- ** assistantGetPageHasPadding+    assistantGetPageHasPadding              ,+++-- ** assistantGetPageHeaderImage+    assistantGetPageHeaderImage             ,+++-- ** assistantGetPageSideImage+    assistantGetPageSideImage               ,+++-- ** assistantGetPageTitle+    assistantGetPageTitle                   ,+++-- ** assistantGetPageType+    assistantGetPageType                    ,+++-- ** assistantInsertPage+    assistantInsertPage                     ,+++-- ** assistantNew+    assistantNew                            ,+++-- ** assistantNextPage+    assistantNextPage                       ,+++-- ** assistantPrependPage+    assistantPrependPage                    ,+++-- ** assistantPreviousPage+    assistantPreviousPage                   ,+++-- ** assistantRemoveActionWidget+    assistantRemoveActionWidget             ,+++-- ** assistantRemovePage+    assistantRemovePage                     ,+++-- ** assistantSetCurrentPage+    assistantSetCurrentPage                 ,+++-- ** assistantSetForwardPageFunc+    assistantSetForwardPageFunc             ,+++-- ** assistantSetPageComplete+    assistantSetPageComplete                ,+++-- ** assistantSetPageHasPadding+    assistantSetPageHasPadding              ,+++-- ** assistantSetPageHeaderImage+    assistantSetPageHeaderImage             ,+++-- ** assistantSetPageSideImage+    assistantSetPageSideImage               ,+++-- ** assistantSetPageTitle+    assistantSetPageTitle                   ,+++-- ** assistantSetPageType+    assistantSetPageType                    ,+++-- ** assistantUpdateButtonsState+    assistantUpdateButtonsState             ,+++++ -- * Properties+-- ** UseHeaderBar+    AssistantUseHeaderBarPropertyInfo       ,+    constructAssistantUseHeaderBar          ,+    getAssistantUseHeaderBar                ,+++++ -- * Signals+-- ** Apply+    AssistantApplyCallback                  ,+    AssistantApplyCallbackC                 ,+    AssistantApplySignalInfo                ,+    afterAssistantApply                     ,+    assistantApplyCallbackWrapper           ,+    assistantApplyClosure                   ,+    mkAssistantApplyCallback                ,+    noAssistantApplyCallback                ,+    onAssistantApply                        ,+++-- ** Cancel+    AssistantCancelCallback                 ,+    AssistantCancelCallbackC                ,+    AssistantCancelSignalInfo               ,+    afterAssistantCancel                    ,+    assistantCancelCallbackWrapper          ,+    assistantCancelClosure                  ,+    mkAssistantCancelCallback               ,+    noAssistantCancelCallback               ,+    onAssistantCancel                       ,+++-- ** Close+    AssistantCloseCallback                  ,+    AssistantCloseCallbackC                 ,+    AssistantCloseSignalInfo                ,+    afterAssistantClose                     ,+    assistantCloseCallbackWrapper           ,+    assistantCloseClosure                   ,+    mkAssistantCloseCallback                ,+    noAssistantCloseCallback                ,+    onAssistantClose                        ,+++-- ** Escape+    AssistantEscapeCallback                 ,+    AssistantEscapeCallbackC                ,+    AssistantEscapeSignalInfo               ,+    afterAssistantEscape                    ,+    assistantEscapeCallbackWrapper          ,+    assistantEscapeClosure                  ,+    mkAssistantEscapeCallback               ,+    noAssistantEscapeCallback               ,+    onAssistantEscape                       ,+++-- ** Prepare+    AssistantPrepareCallback                ,+    AssistantPrepareCallbackC               ,+    AssistantPrepareSignalInfo              ,+    afterAssistantPrepare                   ,+    assistantPrepareCallbackWrapper         ,+    assistantPrepareClosure                 ,+    mkAssistantPrepareCallback              ,+    noAssistantPrepareCallback              ,+    onAssistantPrepare                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.GdkPixbuf as GdkPixbuf++newtype Assistant = Assistant (ForeignPtr Assistant)+foreign import ccall "gtk_assistant_get_type"+    c_gtk_assistant_get_type :: IO GType++type instance ParentTypes Assistant = AssistantParentTypes+type AssistantParentTypes = '[Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Assistant where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_assistant_get_type+    ++class GObject o => AssistantK o+instance (GObject o, IsDescendantOf Assistant o) => AssistantK o++toAssistant :: AssistantK o => o -> IO Assistant+toAssistant = unsafeCastTo Assistant++noAssistant :: Maybe Assistant+noAssistant = Nothing++-- signal Assistant::apply+type AssistantApplyCallback =+    IO ()++noAssistantApplyCallback :: Maybe AssistantApplyCallback+noAssistantApplyCallback = Nothing++type AssistantApplyCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAssistantApplyCallback :: AssistantApplyCallbackC -> IO (FunPtr AssistantApplyCallbackC)++assistantApplyClosure :: AssistantApplyCallback -> IO Closure+assistantApplyClosure cb = newCClosure =<< mkAssistantApplyCallback wrapped+    where wrapped = assistantApplyCallbackWrapper cb++assistantApplyCallbackWrapper ::+    AssistantApplyCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+assistantApplyCallbackWrapper _cb _ _ = do+    _cb ++onAssistantApply :: (GObject a, MonadIO m) => a -> AssistantApplyCallback -> m SignalHandlerId+onAssistantApply obj cb = liftIO $ connectAssistantApply obj cb SignalConnectBefore+afterAssistantApply :: (GObject a, MonadIO m) => a -> AssistantApplyCallback -> m SignalHandlerId+afterAssistantApply obj cb = connectAssistantApply obj cb SignalConnectAfter++connectAssistantApply :: (GObject a, MonadIO m) =>+                         a -> AssistantApplyCallback -> SignalConnectMode -> m SignalHandlerId+connectAssistantApply obj cb after = liftIO $ do+    cb' <- mkAssistantApplyCallback (assistantApplyCallbackWrapper cb)+    connectSignalFunPtr obj "apply" cb' after++-- signal Assistant::cancel+type AssistantCancelCallback =+    IO ()++noAssistantCancelCallback :: Maybe AssistantCancelCallback+noAssistantCancelCallback = Nothing++type AssistantCancelCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAssistantCancelCallback :: AssistantCancelCallbackC -> IO (FunPtr AssistantCancelCallbackC)++assistantCancelClosure :: AssistantCancelCallback -> IO Closure+assistantCancelClosure cb = newCClosure =<< mkAssistantCancelCallback wrapped+    where wrapped = assistantCancelCallbackWrapper cb++assistantCancelCallbackWrapper ::+    AssistantCancelCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+assistantCancelCallbackWrapper _cb _ _ = do+    _cb ++onAssistantCancel :: (GObject a, MonadIO m) => a -> AssistantCancelCallback -> m SignalHandlerId+onAssistantCancel obj cb = liftIO $ connectAssistantCancel obj cb SignalConnectBefore+afterAssistantCancel :: (GObject a, MonadIO m) => a -> AssistantCancelCallback -> m SignalHandlerId+afterAssistantCancel obj cb = connectAssistantCancel obj cb SignalConnectAfter++connectAssistantCancel :: (GObject a, MonadIO m) =>+                          a -> AssistantCancelCallback -> SignalConnectMode -> m SignalHandlerId+connectAssistantCancel obj cb after = liftIO $ do+    cb' <- mkAssistantCancelCallback (assistantCancelCallbackWrapper cb)+    connectSignalFunPtr obj "cancel" cb' after++-- signal Assistant::close+type AssistantCloseCallback =+    IO ()++noAssistantCloseCallback :: Maybe AssistantCloseCallback+noAssistantCloseCallback = Nothing++type AssistantCloseCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAssistantCloseCallback :: AssistantCloseCallbackC -> IO (FunPtr AssistantCloseCallbackC)++assistantCloseClosure :: AssistantCloseCallback -> IO Closure+assistantCloseClosure cb = newCClosure =<< mkAssistantCloseCallback wrapped+    where wrapped = assistantCloseCallbackWrapper cb++assistantCloseCallbackWrapper ::+    AssistantCloseCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+assistantCloseCallbackWrapper _cb _ _ = do+    _cb ++onAssistantClose :: (GObject a, MonadIO m) => a -> AssistantCloseCallback -> m SignalHandlerId+onAssistantClose obj cb = liftIO $ connectAssistantClose obj cb SignalConnectBefore+afterAssistantClose :: (GObject a, MonadIO m) => a -> AssistantCloseCallback -> m SignalHandlerId+afterAssistantClose obj cb = connectAssistantClose obj cb SignalConnectAfter++connectAssistantClose :: (GObject a, MonadIO m) =>+                         a -> AssistantCloseCallback -> SignalConnectMode -> m SignalHandlerId+connectAssistantClose obj cb after = liftIO $ do+    cb' <- mkAssistantCloseCallback (assistantCloseCallbackWrapper cb)+    connectSignalFunPtr obj "close" cb' after++-- signal Assistant::escape+type AssistantEscapeCallback =+    IO ()++noAssistantEscapeCallback :: Maybe AssistantEscapeCallback+noAssistantEscapeCallback = Nothing++type AssistantEscapeCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAssistantEscapeCallback :: AssistantEscapeCallbackC -> IO (FunPtr AssistantEscapeCallbackC)++assistantEscapeClosure :: AssistantEscapeCallback -> IO Closure+assistantEscapeClosure cb = newCClosure =<< mkAssistantEscapeCallback wrapped+    where wrapped = assistantEscapeCallbackWrapper cb++assistantEscapeCallbackWrapper ::+    AssistantEscapeCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+assistantEscapeCallbackWrapper _cb _ _ = do+    _cb ++onAssistantEscape :: (GObject a, MonadIO m) => a -> AssistantEscapeCallback -> m SignalHandlerId+onAssistantEscape obj cb = liftIO $ connectAssistantEscape obj cb SignalConnectBefore+afterAssistantEscape :: (GObject a, MonadIO m) => a -> AssistantEscapeCallback -> m SignalHandlerId+afterAssistantEscape obj cb = connectAssistantEscape obj cb SignalConnectAfter++connectAssistantEscape :: (GObject a, MonadIO m) =>+                          a -> AssistantEscapeCallback -> SignalConnectMode -> m SignalHandlerId+connectAssistantEscape obj cb after = liftIO $ do+    cb' <- mkAssistantEscapeCallback (assistantEscapeCallbackWrapper cb)+    connectSignalFunPtr obj "escape" cb' after++-- signal Assistant::prepare+type AssistantPrepareCallback =+    Widget ->+    IO ()++noAssistantPrepareCallback :: Maybe AssistantPrepareCallback+noAssistantPrepareCallback = Nothing++type AssistantPrepareCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkAssistantPrepareCallback :: AssistantPrepareCallbackC -> IO (FunPtr AssistantPrepareCallbackC)++assistantPrepareClosure :: AssistantPrepareCallback -> IO Closure+assistantPrepareClosure cb = newCClosure =<< mkAssistantPrepareCallback wrapped+    where wrapped = assistantPrepareCallbackWrapper cb++assistantPrepareCallbackWrapper ::+    AssistantPrepareCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+assistantPrepareCallbackWrapper _cb _ page _ = do+    page' <- (newObject Widget) page+    _cb  page'++onAssistantPrepare :: (GObject a, MonadIO m) => a -> AssistantPrepareCallback -> m SignalHandlerId+onAssistantPrepare obj cb = liftIO $ connectAssistantPrepare obj cb SignalConnectBefore+afterAssistantPrepare :: (GObject a, MonadIO m) => a -> AssistantPrepareCallback -> m SignalHandlerId+afterAssistantPrepare obj cb = connectAssistantPrepare obj cb SignalConnectAfter++connectAssistantPrepare :: (GObject a, MonadIO m) =>+                           a -> AssistantPrepareCallback -> SignalConnectMode -> m SignalHandlerId+connectAssistantPrepare obj cb after = liftIO $ do+    cb' <- mkAssistantPrepareCallback (assistantPrepareCallbackWrapper cb)+    connectSignalFunPtr obj "prepare" cb' after++-- VVV Prop "use-header-bar"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getAssistantUseHeaderBar :: (MonadIO m, AssistantK o) => o -> m Int32+getAssistantUseHeaderBar obj = liftIO $ getObjectPropertyCInt obj "use-header-bar"++constructAssistantUseHeaderBar :: Int32 -> IO ([Char], GValue)+constructAssistantUseHeaderBar val = constructObjectPropertyCInt "use-header-bar" val++data AssistantUseHeaderBarPropertyInfo+instance AttrInfo AssistantUseHeaderBarPropertyInfo where+    type AttrAllowedOps AssistantUseHeaderBarPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint AssistantUseHeaderBarPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint AssistantUseHeaderBarPropertyInfo = AssistantK+    type AttrGetType AssistantUseHeaderBarPropertyInfo = Int32+    type AttrLabel AssistantUseHeaderBarPropertyInfo = "Assistant::use-header-bar"+    attrGet _ = getAssistantUseHeaderBar+    attrSet _ = undefined+    attrConstruct _ = constructAssistantUseHeaderBar++type instance AttributeList Assistant = AssistantAttributeList+type AssistantAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", AssistantUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++data AssistantApplySignalInfo+instance SignalInfo AssistantApplySignalInfo where+    type HaskellCallbackType AssistantApplySignalInfo = AssistantApplyCallback+    connectSignal _ = connectAssistantApply++data AssistantCancelSignalInfo+instance SignalInfo AssistantCancelSignalInfo where+    type HaskellCallbackType AssistantCancelSignalInfo = AssistantCancelCallback+    connectSignal _ = connectAssistantCancel++data AssistantCloseSignalInfo+instance SignalInfo AssistantCloseSignalInfo where+    type HaskellCallbackType AssistantCloseSignalInfo = AssistantCloseCallback+    connectSignal _ = connectAssistantClose++data AssistantEscapeSignalInfo+instance SignalInfo AssistantEscapeSignalInfo where+    type HaskellCallbackType AssistantEscapeSignalInfo = AssistantEscapeCallback+    connectSignal _ = connectAssistantEscape++data AssistantPrepareSignalInfo+instance SignalInfo AssistantPrepareSignalInfo where+    type HaskellCallbackType AssistantPrepareSignalInfo = AssistantPrepareCallback+    connectSignal _ = connectAssistantPrepare++type instance SignalList Assistant = AssistantSignalList+type AssistantSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("apply", AssistantApplySignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel", AssistantCancelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", AssistantCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("escape", AssistantEscapeSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("prepare", AssistantPrepareSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Assistant::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Assistant"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_new" gtk_assistant_new :: +    IO (Ptr Assistant)+++assistantNew ::+    (MonadIO m) =>+    m Assistant+assistantNew  = liftIO $ do+    result <- gtk_assistant_new+    checkUnexpectedReturnNULL "gtk_assistant_new" result+    result' <- (newObject Assistant) result+    return result'++-- method Assistant::add_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_add_action_widget" gtk_assistant_add_action_widget :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++assistantAddActionWidget ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+assistantAddActionWidget _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_assistant_add_action_widget _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Assistant::append_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_append_page" gtk_assistant_append_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO Int32+++assistantAppendPage ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m Int32+assistantAppendPage _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_append_page _obj' page'+    touchManagedPtr _obj+    touchManagedPtr page+    return result++-- method Assistant::commit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_commit" gtk_assistant_commit :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO ()+++assistantCommit ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m ()+assistantCommit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_commit _obj'+    touchManagedPtr _obj+    return ()++-- method Assistant::get_current_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_current_page" gtk_assistant_get_current_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO Int32+++assistantGetCurrentPage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m Int32+assistantGetCurrentPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_assistant_get_current_page _obj'+    touchManagedPtr _obj+    return result++-- method Assistant::get_n_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_n_pages" gtk_assistant_get_n_pages :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO Int32+++assistantGetNPages ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m Int32+assistantGetNPages _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_assistant_get_n_pages _obj'+    touchManagedPtr _obj+    return result++-- method Assistant::get_nth_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_nth_page" gtk_assistant_get_nth_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO (Ptr Widget)+++assistantGetNthPage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m Widget+assistantGetNthPage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_assistant_get_nth_page _obj' page_num+    checkUnexpectedReturnNULL "gtk_assistant_get_nth_page" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Assistant::get_page_complete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_complete" gtk_assistant_get_page_complete :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO CInt+++assistantGetPageComplete ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m Bool+assistantGetPageComplete _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_complete _obj' page'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::get_page_has_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_has_padding" gtk_assistant_get_page_has_padding :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO CInt+++assistantGetPageHasPadding ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m Bool+assistantGetPageHasPadding _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_has_padding _obj' page'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::get_page_header_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_header_image" gtk_assistant_get_page_header_image :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO (Ptr GdkPixbuf.Pixbuf)++{-# DEPRECATED assistantGetPageHeaderImage ["(Since version 3.2)","Since GTK+ 3.2, a header is no longer shown;","    add your header decoration to the page content instead."]#-}+assistantGetPageHeaderImage ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m GdkPixbuf.Pixbuf+assistantGetPageHeaderImage _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_header_image _obj' page'+    checkUnexpectedReturnNULL "gtk_assistant_get_page_header_image" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::get_page_side_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_side_image" gtk_assistant_get_page_side_image :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO (Ptr GdkPixbuf.Pixbuf)++{-# DEPRECATED assistantGetPageSideImage ["(Since version 3.2)","Since GTK+ 3.2, sidebar images are not","    shown anymore."]#-}+assistantGetPageSideImage ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m GdkPixbuf.Pixbuf+assistantGetPageSideImage _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_side_image _obj' page'+    checkUnexpectedReturnNULL "gtk_assistant_get_page_side_image" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::get_page_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_title" gtk_assistant_get_page_title :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO CString+++assistantGetPageTitle ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m T.Text+assistantGetPageTitle _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_title _obj' page'+    checkUnexpectedReturnNULL "gtk_assistant_get_page_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::get_page_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AssistantPageType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_get_page_type" gtk_assistant_get_page_type :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO CUInt+++assistantGetPageType ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m AssistantPageType+assistantGetPageType _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_get_page_type _obj' page'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr page+    return result'++-- method Assistant::insert_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", 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 TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_insert_page" gtk_assistant_insert_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO Int32+++assistantInsertPage ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    Int32 ->                                -- position+    m Int32+assistantInsertPage _obj page position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_insert_page _obj' page' position+    touchManagedPtr _obj+    touchManagedPtr page+    return result++-- method Assistant::next_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_next_page" gtk_assistant_next_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO ()+++assistantNextPage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m ()+assistantNextPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_next_page _obj'+    touchManagedPtr _obj+    return ()++-- method Assistant::prepend_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_prepend_page" gtk_assistant_prepend_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    IO Int32+++assistantPrependPage ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    m Int32+assistantPrependPage _obj page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    result <- gtk_assistant_prepend_page _obj' page'+    touchManagedPtr _obj+    touchManagedPtr page+    return result++-- method Assistant::previous_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_previous_page" gtk_assistant_previous_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO ()+++assistantPreviousPage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m ()+assistantPreviousPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_previous_page _obj'+    touchManagedPtr _obj+    return ()++-- method Assistant::remove_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_remove_action_widget" gtk_assistant_remove_action_widget :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++assistantRemoveActionWidget ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+assistantRemoveActionWidget _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_assistant_remove_action_widget _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Assistant::remove_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_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 "gtk_assistant_remove_page" gtk_assistant_remove_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO ()+++assistantRemovePage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m ()+assistantRemovePage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_remove_page _obj' page_num+    touchManagedPtr _obj+    return ()++-- method Assistant::set_current_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_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 "gtk_assistant_set_current_page" gtk_assistant_set_current_page :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO ()+++assistantSetCurrentPage ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m ()+assistantSetCurrentPage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_set_current_page _obj' page_num+    touchManagedPtr _obj+    return ()++-- method Assistant::set_forward_page_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_func", argType = TInterface "Gtk" "AssistantPageFunc", direction = DirectionIn, mayBeNull = True, 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 = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_func", argType = TInterface "Gtk" "AssistantPageFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_set_forward_page_func" gtk_assistant_set_forward_page_func :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    FunPtr AssistantPageFuncC ->            -- page_func : TInterface "Gtk" "AssistantPageFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++assistantSetForwardPageFunc ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    Maybe (AssistantPageFunc) ->            -- page_func+    m ()+assistantSetForwardPageFunc _obj page_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePage_func <- case page_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jPage_func -> do+            jPage_func' <- mkAssistantPageFunc (assistantPageFuncWrapper Nothing jPage_func)+            return jPage_func'+    let data_ = castFunPtrToPtr maybePage_func+    let destroy = safeFreeFunPtrPtr+    gtk_assistant_set_forward_page_func _obj' maybePage_func data_ destroy+    touchManagedPtr _obj+    return ()++-- method Assistant::set_page_complete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "complete", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "complete", 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 "gtk_assistant_set_page_complete" gtk_assistant_set_page_complete :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    CInt ->                                 -- complete : TBasicType TBoolean+    IO ()+++assistantSetPageComplete ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    Bool ->                                 -- complete+    m ()+assistantSetPageComplete _obj page complete = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    let complete' = (fromIntegral . fromEnum) complete+    gtk_assistant_set_page_complete _obj' page' complete'+    touchManagedPtr _obj+    touchManagedPtr page+    return ()++-- method Assistant::set_page_has_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_padding", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_padding", 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 "gtk_assistant_set_page_has_padding" gtk_assistant_set_page_has_padding :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    CInt ->                                 -- has_padding : TBasicType TBoolean+    IO ()+++assistantSetPageHasPadding ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    Bool ->                                 -- has_padding+    m ()+assistantSetPageHasPadding _obj page has_padding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    let has_padding' = (fromIntegral . fromEnum) has_padding+    gtk_assistant_set_page_has_padding _obj' page' has_padding'+    touchManagedPtr _obj+    touchManagedPtr page+    return ()++-- method Assistant::set_page_header_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_set_page_header_image" gtk_assistant_set_page_header_image :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()++{-# DEPRECATED assistantSetPageHeaderImage ["(Since version 3.2)","Since GTK+ 3.2, a header is no longer shown;","    add your header decoration to the page content instead."]#-}+assistantSetPageHeaderImage ::+    (MonadIO m, AssistantK a, WidgetK b, GdkPixbuf.PixbufK c) =>+    a ->                                    -- _obj+    b ->                                    -- page+    Maybe (c) ->                            -- pixbuf+    m ()+assistantSetPageHeaderImage _obj page pixbuf = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    maybePixbuf <- case pixbuf of+        Nothing -> return nullPtr+        Just jPixbuf -> do+            let jPixbuf' = unsafeManagedPtrCastPtr jPixbuf+            return jPixbuf'+    gtk_assistant_set_page_header_image _obj' page' maybePixbuf+    touchManagedPtr _obj+    touchManagedPtr page+    whenJust pixbuf touchManagedPtr+    return ()++-- method Assistant::set_page_side_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_set_page_side_image" gtk_assistant_set_page_side_image :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()++{-# DEPRECATED assistantSetPageSideImage ["(Since version 3.2)","Since GTK+ 3.2, sidebar images are not","    shown anymore."]#-}+assistantSetPageSideImage ::+    (MonadIO m, AssistantK a, WidgetK b, GdkPixbuf.PixbufK c) =>+    a ->                                    -- _obj+    b ->                                    -- page+    Maybe (c) ->                            -- pixbuf+    m ()+assistantSetPageSideImage _obj page pixbuf = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    maybePixbuf <- case pixbuf of+        Nothing -> return nullPtr+        Just jPixbuf -> do+            let jPixbuf' = unsafeManagedPtrCastPtr jPixbuf+            return jPixbuf'+    gtk_assistant_set_page_side_image _obj' page' maybePixbuf+    touchManagedPtr _obj+    touchManagedPtr page+    whenJust pixbuf touchManagedPtr+    return ()++-- method Assistant::set_page_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", 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 "gtk_assistant_set_page_title" gtk_assistant_set_page_title :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++assistantSetPageTitle ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    T.Text ->                               -- title+    m ()+assistantSetPageTitle _obj page title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    title' <- textToCString title+    gtk_assistant_set_page_title _obj' page' title'+    touchManagedPtr _obj+    touchManagedPtr page+    freeMem title'+    return ()++-- method Assistant::set_page_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "AssistantPageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "AssistantPageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_set_page_type" gtk_assistant_set_page_type :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    Ptr Widget ->                           -- page : TInterface "Gtk" "Widget"+    CUInt ->                                -- type : TInterface "Gtk" "AssistantPageType"+    IO ()+++assistantSetPageType ::+    (MonadIO m, AssistantK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- page+    AssistantPageType ->                    -- type+    m ()+assistantSetPageType _obj page type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page' = unsafeManagedPtrCastPtr page+    let type_' = (fromIntegral . fromEnum) type_+    gtk_assistant_set_page_type _obj' page' type_'+    touchManagedPtr _obj+    touchManagedPtr page+    return ()++-- method Assistant::update_buttons_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Assistant", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_assistant_update_buttons_state" gtk_assistant_update_buttons_state :: +    Ptr Assistant ->                        -- _obj : TInterface "Gtk" "Assistant"+    IO ()+++assistantUpdateButtonsState ::+    (MonadIO m, AssistantK a) =>+    a ->                                    -- _obj+    m ()+assistantUpdateButtonsState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_assistant_update_buttons_state _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Assistant.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.Assistant where++import Prelude ()+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 Assistant = Assistant (ForeignPtr Assistant)+instance GObject Assistant where+class GObject o => AssistantK o+instance (GObject o, IsDescendantOf Assistant o) => AssistantK o+data AssistantUseHeaderBarPropertyInfo+data AssistantApplySignalInfo+data AssistantCancelSignalInfo+data AssistantCloseSignalInfo+data AssistantEscapeSignalInfo+data AssistantPrepareSignalInfo
+ GI/Gtk/Objects/Bin.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)+-}++module GI.Gtk.Objects.Bin+    ( ++-- * Exported types+    Bin(..)                                 ,+    BinK                                    ,+    toBin                                   ,+    noBin                                   ,+++ -- * Methods+-- ** binGetChild+    binGetChild                             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Bin = Bin (ForeignPtr Bin)+foreign import ccall "gtk_bin_get_type"+    c_gtk_bin_get_type :: IO GType++type instance ParentTypes Bin = BinParentTypes+type BinParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Bin where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_bin_get_type+    ++class GObject o => BinK o+instance (GObject o, IsDescendantOf Bin o) => BinK o++toBin :: BinK o => o -> IO Bin+toBin = unsafeCastTo Bin++noBin :: Maybe Bin+noBin = Nothing++type instance AttributeList Bin = BinAttributeList+type BinAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Bin = BinSignalList+type BinSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Bin::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_bin_get_child" gtk_bin_get_child :: +    Ptr Bin ->                              -- _obj : TInterface "Gtk" "Bin"+    IO (Ptr Widget)+++binGetChild ::+    (MonadIO m, BinK a) =>+    a ->                                    -- _obj+    m Widget+binGetChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_bin_get_child _obj'+    checkUnexpectedReturnNULL "gtk_bin_get_child" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/Bin.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.Bin where++import Prelude ()+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 Bin = Bin (ForeignPtr Bin)+instance GObject Bin where+class GObject o => BinK o+instance (GObject o, IsDescendantOf Bin o) => BinK o
+ GI/Gtk/Objects/BooleanCellAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.BooleanCellAccessible+    ( ++-- * Exported types+    BooleanCellAccessible(..)               ,+    BooleanCellAccessibleK                  ,+    toBooleanCellAccessible                 ,+    noBooleanCellAccessible                 ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype BooleanCellAccessible = BooleanCellAccessible (ForeignPtr BooleanCellAccessible)+foreign import ccall "gtk_boolean_cell_accessible_get_type"+    c_gtk_boolean_cell_accessible_get_type :: IO GType++type instance ParentTypes BooleanCellAccessible = BooleanCellAccessibleParentTypes+type BooleanCellAccessibleParentTypes = '[RendererCellAccessible, CellAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component]++instance GObject BooleanCellAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_boolean_cell_accessible_get_type+    ++class GObject o => BooleanCellAccessibleK o+instance (GObject o, IsDescendantOf BooleanCellAccessible o) => BooleanCellAccessibleK o++toBooleanCellAccessible :: BooleanCellAccessibleK o => o -> IO BooleanCellAccessible+toBooleanCellAccessible = unsafeCastTo BooleanCellAccessible++noBooleanCellAccessible :: Maybe BooleanCellAccessible+noBooleanCellAccessible = Nothing++type instance AttributeList BooleanCellAccessible = BooleanCellAccessibleAttributeList+type BooleanCellAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("renderer", RendererCellAccessibleRendererPropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList BooleanCellAccessible = BooleanCellAccessibleSignalList+type BooleanCellAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/BooleanCellAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.BooleanCellAccessible where++import Prelude ()+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 BooleanCellAccessible = BooleanCellAccessible (ForeignPtr BooleanCellAccessible)+instance GObject BooleanCellAccessible where+class GObject o => BooleanCellAccessibleK o+instance (GObject o, IsDescendantOf BooleanCellAccessible o) => BooleanCellAccessibleK o
+ GI/Gtk/Objects/Box.hs view
@@ -0,0 +1,641 @@++{- |+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.Gtk.Objects.Box+    ( ++-- * Exported types+    Box(..)                                 ,+    BoxK                                    ,+    toBox                                   ,+    noBox                                   ,+++ -- * Methods+-- ** boxGetBaselinePosition+    boxGetBaselinePosition                  ,+++-- ** boxGetCenterWidget+    boxGetCenterWidget                      ,+++-- ** boxGetHomogeneous+    boxGetHomogeneous                       ,+++-- ** boxGetSpacing+    boxGetSpacing                           ,+++-- ** boxNew+    boxNew                                  ,+++-- ** boxPackEnd+    boxPackEnd                              ,+++-- ** boxPackStart+    boxPackStart                            ,+++-- ** boxQueryChildPacking+    boxQueryChildPacking                    ,+++-- ** boxReorderChild+    boxReorderChild                         ,+++-- ** boxSetBaselinePosition+    boxSetBaselinePosition                  ,+++-- ** boxSetCenterWidget+    boxSetCenterWidget                      ,+++-- ** boxSetChildPacking+    boxSetChildPacking                      ,+++-- ** boxSetHomogeneous+    boxSetHomogeneous                       ,+++-- ** boxSetSpacing+    boxSetSpacing                           ,+++++ -- * Properties+-- ** BaselinePosition+    BoxBaselinePositionPropertyInfo         ,+    constructBoxBaselinePosition            ,+    getBoxBaselinePosition                  ,+    setBoxBaselinePosition                  ,+++-- ** Homogeneous+    BoxHomogeneousPropertyInfo              ,+    constructBoxHomogeneous                 ,+    getBoxHomogeneous                       ,+    setBoxHomogeneous                       ,+++-- ** Spacing+    BoxSpacingPropertyInfo                  ,+    constructBoxSpacing                     ,+    getBoxSpacing                           ,+    setBoxSpacing                           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Box = Box (ForeignPtr Box)+foreign import ccall "gtk_box_get_type"+    c_gtk_box_get_type :: IO GType++type instance ParentTypes Box = BoxParentTypes+type BoxParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject Box where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_box_get_type+    ++class GObject o => BoxK o+instance (GObject o, IsDescendantOf Box o) => BoxK o++toBox :: BoxK o => o -> IO Box+toBox = unsafeCastTo Box++noBox :: Maybe Box+noBox = Nothing++-- VVV Prop "baseline-position"+   -- Type: TInterface "Gtk" "BaselinePosition"+   -- Flags: [PropertyReadable,PropertyWritable]++getBoxBaselinePosition :: (MonadIO m, BoxK o) => o -> m BaselinePosition+getBoxBaselinePosition obj = liftIO $ getObjectPropertyEnum obj "baseline-position"++setBoxBaselinePosition :: (MonadIO m, BoxK o) => o -> BaselinePosition -> m ()+setBoxBaselinePosition obj val = liftIO $ setObjectPropertyEnum obj "baseline-position" val++constructBoxBaselinePosition :: BaselinePosition -> IO ([Char], GValue)+constructBoxBaselinePosition val = constructObjectPropertyEnum "baseline-position" val++data BoxBaselinePositionPropertyInfo+instance AttrInfo BoxBaselinePositionPropertyInfo where+    type AttrAllowedOps BoxBaselinePositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BoxBaselinePositionPropertyInfo = (~) BaselinePosition+    type AttrBaseTypeConstraint BoxBaselinePositionPropertyInfo = BoxK+    type AttrGetType BoxBaselinePositionPropertyInfo = BaselinePosition+    type AttrLabel BoxBaselinePositionPropertyInfo = "Box::baseline-position"+    attrGet _ = getBoxBaselinePosition+    attrSet _ = setBoxBaselinePosition+    attrConstruct _ = constructBoxBaselinePosition++-- VVV Prop "homogeneous"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getBoxHomogeneous :: (MonadIO m, BoxK o) => o -> m Bool+getBoxHomogeneous obj = liftIO $ getObjectPropertyBool obj "homogeneous"++setBoxHomogeneous :: (MonadIO m, BoxK o) => o -> Bool -> m ()+setBoxHomogeneous obj val = liftIO $ setObjectPropertyBool obj "homogeneous" val++constructBoxHomogeneous :: Bool -> IO ([Char], GValue)+constructBoxHomogeneous val = constructObjectPropertyBool "homogeneous" val++data BoxHomogeneousPropertyInfo+instance AttrInfo BoxHomogeneousPropertyInfo where+    type AttrAllowedOps BoxHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BoxHomogeneousPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint BoxHomogeneousPropertyInfo = BoxK+    type AttrGetType BoxHomogeneousPropertyInfo = Bool+    type AttrLabel BoxHomogeneousPropertyInfo = "Box::homogeneous"+    attrGet _ = getBoxHomogeneous+    attrSet _ = setBoxHomogeneous+    attrConstruct _ = constructBoxHomogeneous++-- VVV Prop "spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getBoxSpacing :: (MonadIO m, BoxK o) => o -> m Int32+getBoxSpacing obj = liftIO $ getObjectPropertyCInt obj "spacing"++setBoxSpacing :: (MonadIO m, BoxK o) => o -> Int32 -> m ()+setBoxSpacing obj val = liftIO $ setObjectPropertyCInt obj "spacing" val++constructBoxSpacing :: Int32 -> IO ([Char], GValue)+constructBoxSpacing val = constructObjectPropertyCInt "spacing" val++data BoxSpacingPropertyInfo+instance AttrInfo BoxSpacingPropertyInfo where+    type AttrAllowedOps BoxSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BoxSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint BoxSpacingPropertyInfo = BoxK+    type AttrGetType BoxSpacingPropertyInfo = Int32+    type AttrLabel BoxSpacingPropertyInfo = "Box::spacing"+    attrGet _ = getBoxSpacing+    attrSet _ = setBoxSpacing+    attrConstruct _ = constructBoxSpacing++type instance AttributeList Box = BoxAttributeList+type BoxAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Box = BoxSignalList+type BoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Box::new+-- method type : Constructor+-- Args : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Box"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_new" gtk_box_new :: +    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    Int32 ->                                -- spacing : TBasicType TInt32+    IO (Ptr Box)+++boxNew ::+    (MonadIO m) =>+    Orientation ->                          -- orientation+    Int32 ->                                -- spacing+    m Box+boxNew orientation spacing = liftIO $ do+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- gtk_box_new orientation' spacing+    checkUnexpectedReturnNULL "gtk_box_new" result+    result' <- (newObject Box) result+    return result'++-- method Box::get_baseline_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "BaselinePosition"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_get_baseline_position" gtk_box_get_baseline_position :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    IO CUInt+++boxGetBaselinePosition ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    m BaselinePosition+boxGetBaselinePosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_box_get_baseline_position _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Box::get_center_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_get_center_widget" gtk_box_get_center_widget :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    IO (Ptr Widget)+++boxGetCenterWidget ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    m Widget+boxGetCenterWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_box_get_center_widget _obj'+    checkUnexpectedReturnNULL "gtk_box_get_center_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Box::get_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_get_homogeneous" gtk_box_get_homogeneous :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    IO CInt+++boxGetHomogeneous ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    m Bool+boxGetHomogeneous _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_box_get_homogeneous _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Box::get_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_get_spacing" gtk_box_get_spacing :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    IO Int32+++boxGetSpacing ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    m Int32+boxGetSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_box_get_spacing _obj'+    touchManagedPtr _obj+    return result++-- method Box::pack_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", 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 "gtk_box_pack_end" gtk_box_pack_end :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- expand : TBasicType TBoolean+    CInt ->                                 -- fill : TBasicType TBoolean+    Word32 ->                               -- padding : TBasicType TUInt32+    IO ()+++boxPackEnd ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- expand+    Bool ->                                 -- fill+    Word32 ->                               -- padding+    m ()+boxPackEnd _obj child expand fill padding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let expand' = (fromIntegral . fromEnum) expand+    let fill' = (fromIntegral . fromEnum) fill+    gtk_box_pack_end _obj' child' expand' fill' padding+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Box::pack_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", 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 "gtk_box_pack_start" gtk_box_pack_start :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- expand : TBasicType TBoolean+    CInt ->                                 -- fill : TBasicType TBoolean+    Word32 ->                               -- padding : TBasicType TUInt32+    IO ()+++boxPackStart ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- expand+    Bool ->                                 -- fill+    Word32 ->                               -- padding+    m ()+boxPackStart _obj child expand fill padding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let expand' = (fromIntegral . fromEnum) expand+    let fill' = (fromIntegral . fromEnum) fill+    gtk_box_pack_start _obj' child' expand' fill' padding+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Box::query_child_packing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "padding", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_query_child_packing" gtk_box_query_child_packing :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr CInt ->                             -- expand : TBasicType TBoolean+    Ptr CInt ->                             -- fill : TBasicType TBoolean+    Ptr Word32 ->                           -- padding : TBasicType TUInt32+    Ptr CUInt ->                            -- pack_type : TInterface "Gtk" "PackType"+    IO ()+++boxQueryChildPacking ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m (Bool,Bool,Word32,PackType)+boxQueryChildPacking _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    expand <- allocMem :: IO (Ptr CInt)+    fill <- allocMem :: IO (Ptr CInt)+    padding <- allocMem :: IO (Ptr Word32)+    pack_type <- allocMem :: IO (Ptr CUInt)+    gtk_box_query_child_packing _obj' child' expand fill padding pack_type+    expand' <- peek expand+    let expand'' = (/= 0) expand'+    fill' <- peek fill+    let fill'' = (/= 0) fill'+    padding' <- peek padding+    pack_type' <- peek pack_type+    let pack_type'' = (toEnum . fromIntegral) pack_type'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem expand+    freeMem fill+    freeMem padding+    freeMem pack_type+    return (expand'', fill'', padding', pack_type'')++-- method Box::reorder_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_box_reorder_child" gtk_box_reorder_child :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++boxReorderChild ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+boxReorderChild _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_box_reorder_child _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Box::set_baseline_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "BaselinePosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "BaselinePosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_set_baseline_position" gtk_box_set_baseline_position :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    CUInt ->                                -- position : TInterface "Gtk" "BaselinePosition"+    IO ()+++boxSetBaselinePosition ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    BaselinePosition ->                     -- position+    m ()+boxSetBaselinePosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let position' = (fromIntegral . fromEnum) position+    gtk_box_set_baseline_position _obj' position'+    touchManagedPtr _obj+    return ()++-- method Box::set_center_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_set_center_widget" gtk_box_set_center_widget :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++boxSetCenterWidget ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- widget+    m ()+boxSetCenterWidget _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    gtk_box_set_center_widget _obj' maybeWidget+    touchManagedPtr _obj+    whenJust widget touchManagedPtr+    return ()++-- method Box::set_child_packing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "padding", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_box_set_child_packing" gtk_box_set_child_packing :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- expand : TBasicType TBoolean+    CInt ->                                 -- fill : TBasicType TBoolean+    Word32 ->                               -- padding : TBasicType TUInt32+    CUInt ->                                -- pack_type : TInterface "Gtk" "PackType"+    IO ()+++boxSetChildPacking ::+    (MonadIO m, BoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- expand+    Bool ->                                 -- fill+    Word32 ->                               -- padding+    PackType ->                             -- pack_type+    m ()+boxSetChildPacking _obj child expand fill padding pack_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let expand' = (fromIntegral . fromEnum) expand+    let fill' = (fromIntegral . fromEnum) fill+    let pack_type' = (fromIntegral . fromEnum) pack_type+    gtk_box_set_child_packing _obj' child' expand' fill' padding pack_type'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Box::set_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", 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 "gtk_box_set_homogeneous" gtk_box_set_homogeneous :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    CInt ->                                 -- homogeneous : TBasicType TBoolean+    IO ()+++boxSetHomogeneous ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- homogeneous+    m ()+boxSetHomogeneous _obj homogeneous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    gtk_box_set_homogeneous _obj' homogeneous'+    touchManagedPtr _obj+    return ()++-- method Box::set_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Box", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_box_set_spacing" gtk_box_set_spacing :: +    Ptr Box ->                              -- _obj : TInterface "Gtk" "Box"+    Int32 ->                                -- spacing : TBasicType TInt32+    IO ()+++boxSetSpacing ::+    (MonadIO m, BoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- spacing+    m ()+boxSetSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_box_set_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Box.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.Box where++import Prelude ()+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 Box = Box (ForeignPtr Box)+instance GObject Box where+class GObject o => BoxK o+instance (GObject o, IsDescendantOf Box o) => BoxK o+data BoxBaselinePositionPropertyInfo+data BoxHomogeneousPropertyInfo+data BoxSpacingPropertyInfo
+ GI/Gtk/Objects/Builder.hs view
@@ -0,0 +1,912 @@++{- |+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.Gtk.Objects.Builder+    ( ++-- * Exported types+    Builder(..)                             ,+    BuilderK                                ,+    toBuilder                               ,+    noBuilder                               ,+++ -- * Methods+-- ** builderAddCallbackSymbol+    builderAddCallbackSymbol                ,+++-- ** builderAddFromFile+    builderAddFromFile                      ,+++-- ** builderAddFromResource+    builderAddFromResource                  ,+++-- ** builderAddFromString+    builderAddFromString                    ,+++-- ** builderAddObjectsFromFile+    builderAddObjectsFromFile               ,+++-- ** builderAddObjectsFromResource+    builderAddObjectsFromResource           ,+++-- ** builderAddObjectsFromString+    builderAddObjectsFromString             ,+++-- ** builderConnectSignals+    builderConnectSignals                   ,+++-- ** builderConnectSignalsFull+    builderConnectSignalsFull               ,+++-- ** builderExposeObject+    builderExposeObject                     ,+++-- ** builderGetApplication+    builderGetApplication                   ,+++-- ** builderGetObject+    builderGetObject                        ,+++-- ** builderGetObjects+    builderGetObjects                       ,+++-- ** builderGetTranslationDomain+    builderGetTranslationDomain             ,+++-- ** builderGetTypeFromName+    builderGetTypeFromName                  ,+++-- ** builderNew+    builderNew                              ,+++-- ** builderNewFromFile+    builderNewFromFile                      ,+++-- ** builderNewFromResource+    builderNewFromResource                  ,+++-- ** builderNewFromString+    builderNewFromString                    ,+++-- ** builderSetApplication+    builderSetApplication                   ,+++-- ** builderSetTranslationDomain+    builderSetTranslationDomain             ,+++-- ** builderValueFromString+    builderValueFromString                  ,+++-- ** builderValueFromStringType+    builderValueFromStringType              ,+++++ -- * Properties+-- ** TranslationDomain+    BuilderTranslationDomainPropertyInfo    ,+    constructBuilderTranslationDomain       ,+    getBuilderTranslationDomain             ,+    setBuilderTranslationDomain             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype Builder = Builder (ForeignPtr Builder)+foreign import ccall "gtk_builder_get_type"+    c_gtk_builder_get_type :: IO GType++type instance ParentTypes Builder = BuilderParentTypes+type BuilderParentTypes = '[GObject.Object]++instance GObject Builder where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_builder_get_type+    ++class GObject o => BuilderK o+instance (GObject o, IsDescendantOf Builder o) => BuilderK o++toBuilder :: BuilderK o => o -> IO Builder+toBuilder = unsafeCastTo Builder++noBuilder :: Maybe Builder+noBuilder = Nothing++-- VVV Prop "translation-domain"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getBuilderTranslationDomain :: (MonadIO m, BuilderK o) => o -> m T.Text+getBuilderTranslationDomain obj = liftIO $ getObjectPropertyString obj "translation-domain"++setBuilderTranslationDomain :: (MonadIO m, BuilderK o) => o -> T.Text -> m ()+setBuilderTranslationDomain obj val = liftIO $ setObjectPropertyString obj "translation-domain" val++constructBuilderTranslationDomain :: T.Text -> IO ([Char], GValue)+constructBuilderTranslationDomain val = constructObjectPropertyString "translation-domain" val++data BuilderTranslationDomainPropertyInfo+instance AttrInfo BuilderTranslationDomainPropertyInfo where+    type AttrAllowedOps BuilderTranslationDomainPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BuilderTranslationDomainPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint BuilderTranslationDomainPropertyInfo = BuilderK+    type AttrGetType BuilderTranslationDomainPropertyInfo = T.Text+    type AttrLabel BuilderTranslationDomainPropertyInfo = "Builder::translation-domain"+    attrGet _ = getBuilderTranslationDomain+    attrSet _ = setBuilderTranslationDomain+    attrConstruct _ = constructBuilderTranslationDomain++type instance AttributeList Builder = BuilderAttributeList+type BuilderAttributeList = ('[ '("translation-domain", BuilderTranslationDomainPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Builder = BuilderSignalList+type BuilderSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Builder::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Builder"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_new" gtk_builder_new :: +    IO (Ptr Builder)+++builderNew ::+    (MonadIO m) =>+    m Builder+builderNew  = liftIO $ do+    result <- gtk_builder_new+    checkUnexpectedReturnNULL "gtk_builder_new" result+    result' <- (wrapObject Builder) result+    return result'++-- method Builder::new_from_file+-- 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 "Gtk" "Builder"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_new_from_file" gtk_builder_new_from_file :: +    CString ->                              -- filename : TBasicType TUTF8+    IO (Ptr Builder)+++builderNewFromFile ::+    (MonadIO m) =>+    T.Text ->                               -- filename+    m Builder+builderNewFromFile filename = liftIO $ do+    filename' <- textToCString filename+    result <- gtk_builder_new_from_file filename'+    checkUnexpectedReturnNULL "gtk_builder_new_from_file" result+    result' <- (wrapObject Builder) result+    freeMem filename'+    return result'++-- method Builder::new_from_resource+-- method type : Constructor+-- Args : [Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Builder"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_new_from_resource" gtk_builder_new_from_resource :: +    CString ->                              -- resource_path : TBasicType TUTF8+    IO (Ptr Builder)+++builderNewFromResource ::+    (MonadIO m) =>+    T.Text ->                               -- resource_path+    m Builder+builderNewFromResource resource_path = liftIO $ do+    resource_path' <- textToCString resource_path+    result <- gtk_builder_new_from_resource resource_path'+    checkUnexpectedReturnNULL "gtk_builder_new_from_resource" result+    result' <- (wrapObject Builder) result+    freeMem resource_path'+    return result'++-- method Builder::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},Arg {argName = "length", argType = TBasicType TInt64, 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},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Builder"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_new_from_string" gtk_builder_new_from_string :: +    CString ->                              -- string : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    IO (Ptr Builder)+++builderNewFromString ::+    (MonadIO m) =>+    T.Text ->                               -- string+    Int64 ->                                -- length+    m Builder+builderNewFromString string length_ = liftIO $ do+    string' <- textToCString string+    result <- gtk_builder_new_from_string string' length_+    checkUnexpectedReturnNULL "gtk_builder_new_from_string" result+    result' <- (wrapObject Builder) result+    freeMem string'+    return result'++-- method Builder::add_callback_symbol+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_symbol", argType = TInterface "GObject" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback_symbol", argType = TInterface "GObject" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_add_callback_symbol" gtk_builder_add_callback_symbol :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- callback_name : TBasicType TUTF8+    FunPtr GObject.CallbackC ->             -- callback_symbol : TInterface "GObject" "Callback"+    IO ()+++builderAddCallbackSymbol ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- callback_name+    GObject.Callback ->                     -- callback_symbol+    m ()+builderAddCallbackSymbol _obj callback_name callback_symbol = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    callback_name' <- textToCString callback_name+    ptrcallback_symbol <- callocMem :: IO (Ptr (FunPtr GObject.CallbackC))+    callback_symbol' <- GObject.mkCallback (GObject.callbackWrapper (Just ptrcallback_symbol) callback_symbol)+    poke ptrcallback_symbol callback_symbol'+    gtk_builder_add_callback_symbol _obj' callback_name' callback_symbol'+    touchManagedPtr _obj+    freeMem callback_name'+    return ()++-- method Builder::add_from_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_from_file" gtk_builder_add_from_file :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- filename : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddFromFile ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- filename+    m Word32+builderAddFromFile _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- textToCString filename+    onException (do+        result <- propagateGError $ gtk_builder_add_from_file _obj' filename'+        touchManagedPtr _obj+        freeMem filename'+        return result+     ) (do+        freeMem filename'+     )++-- method Builder::add_from_resource+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_from_resource" gtk_builder_add_from_resource :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- resource_path : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddFromResource ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- resource_path+    m Word32+builderAddFromResource _obj resource_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    resource_path' <- textToCString resource_path+    onException (do+        result <- propagateGError $ gtk_builder_add_from_resource _obj' resource_path'+        touchManagedPtr _obj+        freeMem resource_path'+        return result+     ) (do+        freeMem resource_path'+     )++-- method Builder::add_from_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TBasicType TUTF8, 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}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_from_string" gtk_builder_add_from_string :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- buffer : TBasicType TUTF8+    Word64 ->                               -- length : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddFromString ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- buffer+    Word64 ->                               -- length+    m Word32+builderAddFromString _obj buffer length_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- textToCString buffer+    onException (do+        result <- propagateGError $ gtk_builder_add_from_string _obj' buffer' length_+        touchManagedPtr _obj+        freeMem buffer'+        return result+     ) (do+        freeMem buffer'+     )++-- method Builder::add_objects_from_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_ids", 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 "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_ids", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_objects_from_file" gtk_builder_add_objects_from_file :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- filename : TBasicType TUTF8+    Ptr CString ->                          -- object_ids : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddObjectsFromFile ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- filename+    [T.Text] ->                             -- object_ids+    m Word32+builderAddObjectsFromFile _obj filename object_ids = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- textToCString filename+    object_ids' <- packZeroTerminatedUTF8CArray object_ids+    onException (do+        result <- propagateGError $ gtk_builder_add_objects_from_file _obj' filename' object_ids'+        touchManagedPtr _obj+        freeMem filename'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+        return result+     ) (do+        freeMem filename'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+     )++-- method Builder::add_objects_from_resource+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_ids", 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 "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "object_ids", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_objects_from_resource" gtk_builder_add_objects_from_resource :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- resource_path : TBasicType TUTF8+    Ptr CString ->                          -- object_ids : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddObjectsFromResource ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- resource_path+    [T.Text] ->                             -- object_ids+    m Word32+builderAddObjectsFromResource _obj resource_path object_ids = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    resource_path' <- textToCString resource_path+    object_ids' <- packZeroTerminatedUTF8CArray object_ids+    onException (do+        result <- propagateGError $ gtk_builder_add_objects_from_resource _obj' resource_path' object_ids'+        touchManagedPtr _obj+        freeMem resource_path'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+        return result+     ) (do+        freeMem resource_path'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+     )++-- method Builder::add_objects_from_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TBasicType TUTF8, 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 = "object_ids", 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 "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TBasicType TUTF8, 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 = "object_ids", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : True+-- Skip return : False++foreign import ccall "gtk_builder_add_objects_from_string" gtk_builder_add_objects_from_string :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- buffer : TBasicType TUTF8+    Word64 ->                               -- length : TBasicType TUInt64+    Ptr CString ->                          -- object_ids : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO Word32+++builderAddObjectsFromString ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- buffer+    Word64 ->                               -- length+    [T.Text] ->                             -- object_ids+    m Word32+builderAddObjectsFromString _obj buffer length_ object_ids = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- textToCString buffer+    object_ids' <- packZeroTerminatedUTF8CArray object_ids+    onException (do+        result <- propagateGError $ gtk_builder_add_objects_from_string _obj' buffer' length_ object_ids'+        touchManagedPtr _obj+        freeMem buffer'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+        return result+     ) (do+        freeMem buffer'+        mapZeroTerminatedCArray freeMem object_ids'+        freeMem object_ids'+     )++-- method Builder::connect_signals+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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 : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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 "gtk_builder_connect_signals" gtk_builder_connect_signals :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++builderConnectSignals ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    Ptr () ->                               -- user_data+    m ()+builderConnectSignals _obj user_data = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_builder_connect_signals _obj' user_data+    touchManagedPtr _obj+    return ()++-- method Builder::connect_signals_full+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "BuilderConnectFunc", 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 "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "BuilderConnectFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_connect_signals_full" gtk_builder_connect_signals_full :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    FunPtr BuilderConnectFuncC ->           -- func : TInterface "Gtk" "BuilderConnectFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++builderConnectSignalsFull ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    BuilderConnectFunc ->                   -- func+    m ()+builderConnectSignalsFull _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkBuilderConnectFunc (builderConnectFuncWrapper Nothing func)+    let user_data = nullPtr+    gtk_builder_connect_signals_full _obj' func' user_data+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method Builder::expose_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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", 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 "gtk_builder_expose_object" gtk_builder_expose_object :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- name : TBasicType TUTF8+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    IO ()+++builderExposeObject ::+    (MonadIO m, BuilderK a, GObject.ObjectK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    b ->                                    -- object+    m ()+builderExposeObject _obj name object = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    let object' = unsafeManagedPtrCastPtr object+    gtk_builder_expose_object _obj' name' object'+    touchManagedPtr _obj+    touchManagedPtr object+    freeMem name'+    return ()++-- method Builder::get_application+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Application"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_get_application" gtk_builder_get_application :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    IO (Ptr Application)+++builderGetApplication ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    m Application+builderGetApplication _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_builder_get_application _obj'+    checkUnexpectedReturnNULL "gtk_builder_get_application" result+    result' <- (newObject Application) result+    touchManagedPtr _obj+    return result'++-- method Builder::get_object+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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 "Gtk" "Builder", 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 "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_get_object" gtk_builder_get_object :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GObject.Object)+++builderGetObject ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m GObject.Object+builderGetObject _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gtk_builder_get_object _obj' name'+    checkUnexpectedReturnNULL "gtk_builder_get_object" result+    result' <- (newObject GObject.Object) result+    touchManagedPtr _obj+    freeMem name'+    return result'++-- method Builder::get_objects+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "GObject" "Object")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_get_objects" gtk_builder_get_objects :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    IO (Ptr (GSList (Ptr GObject.Object)))+++builderGetObjects ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    m [GObject.Object]+builderGetObjects _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_builder_get_objects _obj'+    checkUnexpectedReturnNULL "gtk_builder_get_objects" result+    result' <- unpackGSList result+    result'' <- mapM (newObject GObject.Object) result'+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method Builder::get_translation_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_get_translation_domain" gtk_builder_get_translation_domain :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    IO CString+++builderGetTranslationDomain ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    m T.Text+builderGetTranslationDomain _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_builder_get_translation_domain _obj'+    checkUnexpectedReturnNULL "gtk_builder_get_translation_domain" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Builder::get_type_from_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_get_type_from_name" gtk_builder_get_type_from_name :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- type_name : TBasicType TUTF8+    IO CGType+++builderGetTypeFromName ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- type_name+    m GType+builderGetTypeFromName _obj type_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    type_name' <- textToCString type_name+    result <- gtk_builder_get_type_from_name _obj' type_name'+    let result' = GType result+    touchManagedPtr _obj+    freeMem type_name'+    return result'++-- method Builder::set_application+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "application", argType = TInterface "Gtk" "Application", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_builder_set_application" gtk_builder_set_application :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    Ptr Application ->                      -- application : TInterface "Gtk" "Application"+    IO ()+++builderSetApplication ::+    (MonadIO m, BuilderK a, ApplicationK b) =>+    a ->                                    -- _obj+    b ->                                    -- application+    m ()+builderSetApplication _obj application = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let application' = unsafeManagedPtrCastPtr application+    gtk_builder_set_application _obj' application'+    touchManagedPtr _obj+    touchManagedPtr application+    return ()++-- method Builder::set_translation_domain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "domain", 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 "gtk_builder_set_translation_domain" gtk_builder_set_translation_domain :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CString ->                              -- domain : TBasicType TUTF8+    IO ()+++builderSetTranslationDomain ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- domain+    m ()+builderSetTranslationDomain _obj domain = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDomain <- case domain of+        Nothing -> return nullPtr+        Just jDomain -> do+            jDomain' <- textToCString jDomain+            return jDomain'+    gtk_builder_set_translation_domain _obj' maybeDomain+    touchManagedPtr _obj+    freeMem maybeDomain+    return ()++-- method Builder::value_from_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},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 "gtk_builder_value_from_string" gtk_builder_value_from_string :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    Ptr GParamSpec ->                       -- pspec : TParamSpec+    CString ->                              -- string : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++builderValueFromString ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    GParamSpec ->                           -- pspec+    T.Text ->                               -- string+    m (GValue)+builderValueFromString _obj pspec string = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pspec' = unsafeManagedPtrGetPtr pspec+    string' <- textToCString string+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    onException (do+        _ <- propagateGError $ gtk_builder_value_from_string _obj' pspec' string' value+        value' <- (wrapBoxed GValue) value+        touchManagedPtr _obj+        freeMem string'+        return value'+     ) (do+        freeMem string'+        freeMem value+     )++-- method Builder::value_from_string_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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 = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Builder", 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 = "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 "gtk_builder_value_from_string_type" gtk_builder_value_from_string_type :: +    Ptr Builder ->                          -- _obj : TInterface "Gtk" "Builder"+    CGType ->                               -- type : TBasicType TGType+    CString ->                              -- string : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++builderValueFromStringType ::+    (MonadIO m, BuilderK a) =>+    a ->                                    -- _obj+    GType ->                                -- type+    T.Text ->                               -- string+    m (GValue)+builderValueFromStringType _obj type_ string = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = gtypeToCGType type_+    string' <- textToCString string+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    onException (do+        _ <- propagateGError $ gtk_builder_value_from_string_type _obj' type_' string' value+        value' <- (wrapBoxed GValue) value+        touchManagedPtr _obj+        freeMem string'+        return value'+     ) (do+        freeMem string'+        freeMem value+     )++
+ GI/Gtk/Objects/Builder.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.Builder where++import Prelude ()+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 Builder = Builder (ForeignPtr Builder)+instance GObject Builder where+class GObject o => BuilderK o+instance (GObject o, IsDescendantOf Builder o) => BuilderK o+data BuilderTranslationDomainPropertyInfo
+ GI/Gtk/Objects/Button.hs view
@@ -0,0 +1,1583 @@++{- |+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.Gtk.Objects.Button+    ( ++-- * Exported types+    Button(..)                              ,+    ButtonK                                 ,+    toButton                                ,+    noButton                                ,+++ -- * Methods+-- ** buttonClicked+    buttonClicked                           ,+++-- ** buttonEnter+    buttonEnter                             ,+++-- ** buttonGetAlignment+    buttonGetAlignment                      ,+++-- ** buttonGetAlwaysShowImage+    buttonGetAlwaysShowImage                ,+++-- ** buttonGetEventWindow+    buttonGetEventWindow                    ,+++-- ** buttonGetFocusOnClick+    buttonGetFocusOnClick                   ,+++-- ** buttonGetImage+    buttonGetImage                          ,+++-- ** buttonGetImagePosition+    buttonGetImagePosition                  ,+++-- ** buttonGetLabel+    buttonGetLabel                          ,+++-- ** buttonGetRelief+    buttonGetRelief                         ,+++-- ** buttonGetUseStock+    buttonGetUseStock                       ,+++-- ** buttonGetUseUnderline+    buttonGetUseUnderline                   ,+++-- ** buttonLeave+    buttonLeave                             ,+++-- ** buttonNew+    buttonNew                               ,+++-- ** buttonNewFromIconName+    buttonNewFromIconName                   ,+++-- ** buttonNewFromStock+    buttonNewFromStock                      ,+++-- ** buttonNewWithLabel+    buttonNewWithLabel                      ,+++-- ** buttonNewWithMnemonic+    buttonNewWithMnemonic                   ,+++-- ** buttonPressed+    buttonPressed                           ,+++-- ** buttonReleased+    buttonReleased                          ,+++-- ** buttonSetAlignment+    buttonSetAlignment                      ,+++-- ** buttonSetAlwaysShowImage+    buttonSetAlwaysShowImage                ,+++-- ** buttonSetFocusOnClick+    buttonSetFocusOnClick                   ,+++-- ** buttonSetImage+    buttonSetImage                          ,+++-- ** buttonSetImagePosition+    buttonSetImagePosition                  ,+++-- ** buttonSetLabel+    buttonSetLabel                          ,+++-- ** buttonSetRelief+    buttonSetRelief                         ,+++-- ** buttonSetUseStock+    buttonSetUseStock                       ,+++-- ** buttonSetUseUnderline+    buttonSetUseUnderline                   ,+++++ -- * Properties+-- ** AlwaysShowImage+    ButtonAlwaysShowImagePropertyInfo       ,+    constructButtonAlwaysShowImage          ,+    getButtonAlwaysShowImage                ,+    setButtonAlwaysShowImage                ,+++-- ** FocusOnClick+    ButtonFocusOnClickPropertyInfo          ,+    constructButtonFocusOnClick             ,+    getButtonFocusOnClick                   ,+    setButtonFocusOnClick                   ,+++-- ** Image+    ButtonImagePropertyInfo                 ,+    constructButtonImage                    ,+    getButtonImage                          ,+    setButtonImage                          ,+++-- ** ImagePosition+    ButtonImagePositionPropertyInfo         ,+    constructButtonImagePosition            ,+    getButtonImagePosition                  ,+    setButtonImagePosition                  ,+++-- ** Label+    ButtonLabelPropertyInfo                 ,+    constructButtonLabel                    ,+    getButtonLabel                          ,+    setButtonLabel                          ,+++-- ** Relief+    ButtonReliefPropertyInfo                ,+    constructButtonRelief                   ,+    getButtonRelief                         ,+    setButtonRelief                         ,+++-- ** UseStock+    ButtonUseStockPropertyInfo              ,+    constructButtonUseStock                 ,+    getButtonUseStock                       ,+    setButtonUseStock                       ,+++-- ** UseUnderline+    ButtonUseUnderlinePropertyInfo          ,+    constructButtonUseUnderline             ,+    getButtonUseUnderline                   ,+    setButtonUseUnderline                   ,+++-- ** Xalign+    ButtonXalignPropertyInfo                ,+    constructButtonXalign                   ,+    getButtonXalign                         ,+    setButtonXalign                         ,+++-- ** Yalign+    ButtonYalignPropertyInfo                ,+    constructButtonYalign                   ,+    getButtonYalign                         ,+    setButtonYalign                         ,+++++ -- * Signals+-- ** Activate+    ButtonActivateCallback                  ,+    ButtonActivateCallbackC                 ,+    ButtonActivateSignalInfo                ,+    afterButtonActivate                     ,+    buttonActivateCallbackWrapper           ,+    buttonActivateClosure                   ,+    mkButtonActivateCallback                ,+    noButtonActivateCallback                ,+    onButtonActivate                        ,+++-- ** Clicked+    ButtonClickedCallback                   ,+    ButtonClickedCallbackC                  ,+    ButtonClickedSignalInfo                 ,+    afterButtonClicked                      ,+    buttonClickedCallbackWrapper            ,+    buttonClickedClosure                    ,+    mkButtonClickedCallback                 ,+    noButtonClickedCallback                 ,+    onButtonClicked                         ,+++-- ** Enter+    ButtonEnterCallback                     ,+    ButtonEnterCallbackC                    ,+    ButtonEnterSignalInfo                   ,+    afterButtonEnter                        ,+    buttonEnterCallbackWrapper              ,+    buttonEnterClosure                      ,+    mkButtonEnterCallback                   ,+    noButtonEnterCallback                   ,+    onButtonEnter                           ,+++-- ** Leave+    ButtonLeaveCallback                     ,+    ButtonLeaveCallbackC                    ,+    ButtonLeaveSignalInfo                   ,+    afterButtonLeave                        ,+    buttonLeaveCallbackWrapper              ,+    buttonLeaveClosure                      ,+    mkButtonLeaveCallback                   ,+    noButtonLeaveCallback                   ,+    onButtonLeave                           ,+++-- ** Pressed+    ButtonPressedCallback                   ,+    ButtonPressedCallbackC                  ,+    ButtonPressedSignalInfo                 ,+    afterButtonPressed                      ,+    buttonPressedCallbackWrapper            ,+    buttonPressedClosure                    ,+    mkButtonPressedCallback                 ,+    noButtonPressedCallback                 ,+    onButtonPressed                         ,+++-- ** Released+    ButtonReleasedCallback                  ,+    ButtonReleasedCallbackC                 ,+    ButtonReleasedSignalInfo                ,+    afterButtonReleased                     ,+    buttonReleasedCallbackWrapper           ,+    buttonReleasedClosure                   ,+    mkButtonReleasedCallback                ,+    noButtonReleasedCallback                ,+    onButtonReleased                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Button = Button (ForeignPtr Button)+foreign import ccall "gtk_button_get_type"+    c_gtk_button_get_type :: IO GType++type instance ParentTypes Button = ButtonParentTypes+type ButtonParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject Button where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_button_get_type+    ++class GObject o => ButtonK o+instance (GObject o, IsDescendantOf Button o) => ButtonK o++toButton :: ButtonK o => o -> IO Button+toButton = unsafeCastTo Button++noButton :: Maybe Button+noButton = Nothing++-- signal Button::activate+type ButtonActivateCallback =+    IO ()++noButtonActivateCallback :: Maybe ButtonActivateCallback+noButtonActivateCallback = Nothing++type ButtonActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonActivateCallback :: ButtonActivateCallbackC -> IO (FunPtr ButtonActivateCallbackC)++buttonActivateClosure :: ButtonActivateCallback -> IO Closure+buttonActivateClosure cb = newCClosure =<< mkButtonActivateCallback wrapped+    where wrapped = buttonActivateCallbackWrapper cb++buttonActivateCallbackWrapper ::+    ButtonActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonActivateCallbackWrapper _cb _ _ = do+    _cb ++onButtonActivate :: (GObject a, MonadIO m) => a -> ButtonActivateCallback -> m SignalHandlerId+onButtonActivate obj cb = liftIO $ connectButtonActivate obj cb SignalConnectBefore+afterButtonActivate :: (GObject a, MonadIO m) => a -> ButtonActivateCallback -> m SignalHandlerId+afterButtonActivate obj cb = connectButtonActivate obj cb SignalConnectAfter++connectButtonActivate :: (GObject a, MonadIO m) =>+                         a -> ButtonActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonActivate obj cb after = liftIO $ do+    cb' <- mkButtonActivateCallback (buttonActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- signal Button::clicked+type ButtonClickedCallback =+    IO ()++noButtonClickedCallback :: Maybe ButtonClickedCallback+noButtonClickedCallback = Nothing++type ButtonClickedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonClickedCallback :: ButtonClickedCallbackC -> IO (FunPtr ButtonClickedCallbackC)++buttonClickedClosure :: ButtonClickedCallback -> IO Closure+buttonClickedClosure cb = newCClosure =<< mkButtonClickedCallback wrapped+    where wrapped = buttonClickedCallbackWrapper cb++buttonClickedCallbackWrapper ::+    ButtonClickedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonClickedCallbackWrapper _cb _ _ = do+    _cb ++onButtonClicked :: (GObject a, MonadIO m) => a -> ButtonClickedCallback -> m SignalHandlerId+onButtonClicked obj cb = liftIO $ connectButtonClicked obj cb SignalConnectBefore+afterButtonClicked :: (GObject a, MonadIO m) => a -> ButtonClickedCallback -> m SignalHandlerId+afterButtonClicked obj cb = connectButtonClicked obj cb SignalConnectAfter++connectButtonClicked :: (GObject a, MonadIO m) =>+                        a -> ButtonClickedCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonClicked obj cb after = liftIO $ do+    cb' <- mkButtonClickedCallback (buttonClickedCallbackWrapper cb)+    connectSignalFunPtr obj "clicked" cb' after++-- signal Button::enter+type ButtonEnterCallback =+    IO ()++noButtonEnterCallback :: Maybe ButtonEnterCallback+noButtonEnterCallback = Nothing++type ButtonEnterCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonEnterCallback :: ButtonEnterCallbackC -> IO (FunPtr ButtonEnterCallbackC)++buttonEnterClosure :: ButtonEnterCallback -> IO Closure+buttonEnterClosure cb = newCClosure =<< mkButtonEnterCallback wrapped+    where wrapped = buttonEnterCallbackWrapper cb++buttonEnterCallbackWrapper ::+    ButtonEnterCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonEnterCallbackWrapper _cb _ _ = do+    _cb ++onButtonEnter :: (GObject a, MonadIO m) => a -> ButtonEnterCallback -> m SignalHandlerId+onButtonEnter obj cb = liftIO $ connectButtonEnter obj cb SignalConnectBefore+afterButtonEnter :: (GObject a, MonadIO m) => a -> ButtonEnterCallback -> m SignalHandlerId+afterButtonEnter obj cb = connectButtonEnter obj cb SignalConnectAfter++connectButtonEnter :: (GObject a, MonadIO m) =>+                      a -> ButtonEnterCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonEnter obj cb after = liftIO $ do+    cb' <- mkButtonEnterCallback (buttonEnterCallbackWrapper cb)+    connectSignalFunPtr obj "enter" cb' after++-- signal Button::leave+type ButtonLeaveCallback =+    IO ()++noButtonLeaveCallback :: Maybe ButtonLeaveCallback+noButtonLeaveCallback = Nothing++type ButtonLeaveCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonLeaveCallback :: ButtonLeaveCallbackC -> IO (FunPtr ButtonLeaveCallbackC)++buttonLeaveClosure :: ButtonLeaveCallback -> IO Closure+buttonLeaveClosure cb = newCClosure =<< mkButtonLeaveCallback wrapped+    where wrapped = buttonLeaveCallbackWrapper cb++buttonLeaveCallbackWrapper ::+    ButtonLeaveCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonLeaveCallbackWrapper _cb _ _ = do+    _cb ++onButtonLeave :: (GObject a, MonadIO m) => a -> ButtonLeaveCallback -> m SignalHandlerId+onButtonLeave obj cb = liftIO $ connectButtonLeave obj cb SignalConnectBefore+afterButtonLeave :: (GObject a, MonadIO m) => a -> ButtonLeaveCallback -> m SignalHandlerId+afterButtonLeave obj cb = connectButtonLeave obj cb SignalConnectAfter++connectButtonLeave :: (GObject a, MonadIO m) =>+                      a -> ButtonLeaveCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonLeave obj cb after = liftIO $ do+    cb' <- mkButtonLeaveCallback (buttonLeaveCallbackWrapper cb)+    connectSignalFunPtr obj "leave" cb' after++-- signal Button::pressed+type ButtonPressedCallback =+    IO ()++noButtonPressedCallback :: Maybe ButtonPressedCallback+noButtonPressedCallback = Nothing++type ButtonPressedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonPressedCallback :: ButtonPressedCallbackC -> IO (FunPtr ButtonPressedCallbackC)++buttonPressedClosure :: ButtonPressedCallback -> IO Closure+buttonPressedClosure cb = newCClosure =<< mkButtonPressedCallback wrapped+    where wrapped = buttonPressedCallbackWrapper cb++buttonPressedCallbackWrapper ::+    ButtonPressedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonPressedCallbackWrapper _cb _ _ = do+    _cb ++onButtonPressed :: (GObject a, MonadIO m) => a -> ButtonPressedCallback -> m SignalHandlerId+onButtonPressed obj cb = liftIO $ connectButtonPressed obj cb SignalConnectBefore+afterButtonPressed :: (GObject a, MonadIO m) => a -> ButtonPressedCallback -> m SignalHandlerId+afterButtonPressed obj cb = connectButtonPressed obj cb SignalConnectAfter++connectButtonPressed :: (GObject a, MonadIO m) =>+                        a -> ButtonPressedCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonPressed obj cb after = liftIO $ do+    cb' <- mkButtonPressedCallback (buttonPressedCallbackWrapper cb)+    connectSignalFunPtr obj "pressed" cb' after++-- signal Button::released+type ButtonReleasedCallback =+    IO ()++noButtonReleasedCallback :: Maybe ButtonReleasedCallback+noButtonReleasedCallback = Nothing++type ButtonReleasedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkButtonReleasedCallback :: ButtonReleasedCallbackC -> IO (FunPtr ButtonReleasedCallbackC)++buttonReleasedClosure :: ButtonReleasedCallback -> IO Closure+buttonReleasedClosure cb = newCClosure =<< mkButtonReleasedCallback wrapped+    where wrapped = buttonReleasedCallbackWrapper cb++buttonReleasedCallbackWrapper ::+    ButtonReleasedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+buttonReleasedCallbackWrapper _cb _ _ = do+    _cb ++onButtonReleased :: (GObject a, MonadIO m) => a -> ButtonReleasedCallback -> m SignalHandlerId+onButtonReleased obj cb = liftIO $ connectButtonReleased obj cb SignalConnectBefore+afterButtonReleased :: (GObject a, MonadIO m) => a -> ButtonReleasedCallback -> m SignalHandlerId+afterButtonReleased obj cb = connectButtonReleased obj cb SignalConnectAfter++connectButtonReleased :: (GObject a, MonadIO m) =>+                         a -> ButtonReleasedCallback -> SignalConnectMode -> m SignalHandlerId+connectButtonReleased obj cb after = liftIO $ do+    cb' <- mkButtonReleasedCallback (buttonReleasedCallbackWrapper cb)+    connectSignalFunPtr obj "released" cb' after++-- VVV Prop "always-show-image"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getButtonAlwaysShowImage :: (MonadIO m, ButtonK o) => o -> m Bool+getButtonAlwaysShowImage obj = liftIO $ getObjectPropertyBool obj "always-show-image"++setButtonAlwaysShowImage :: (MonadIO m, ButtonK o) => o -> Bool -> m ()+setButtonAlwaysShowImage obj val = liftIO $ setObjectPropertyBool obj "always-show-image" val++constructButtonAlwaysShowImage :: Bool -> IO ([Char], GValue)+constructButtonAlwaysShowImage val = constructObjectPropertyBool "always-show-image" val++data ButtonAlwaysShowImagePropertyInfo+instance AttrInfo ButtonAlwaysShowImagePropertyInfo where+    type AttrAllowedOps ButtonAlwaysShowImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonAlwaysShowImagePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ButtonAlwaysShowImagePropertyInfo = ButtonK+    type AttrGetType ButtonAlwaysShowImagePropertyInfo = Bool+    type AttrLabel ButtonAlwaysShowImagePropertyInfo = "Button::always-show-image"+    attrGet _ = getButtonAlwaysShowImage+    attrSet _ = setButtonAlwaysShowImage+    attrConstruct _ = constructButtonAlwaysShowImage++-- VVV Prop "focus-on-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonFocusOnClick :: (MonadIO m, ButtonK o) => o -> m Bool+getButtonFocusOnClick obj = liftIO $ getObjectPropertyBool obj "focus-on-click"++setButtonFocusOnClick :: (MonadIO m, ButtonK o) => o -> Bool -> m ()+setButtonFocusOnClick obj val = liftIO $ setObjectPropertyBool obj "focus-on-click" val++constructButtonFocusOnClick :: Bool -> IO ([Char], GValue)+constructButtonFocusOnClick val = constructObjectPropertyBool "focus-on-click" val++data ButtonFocusOnClickPropertyInfo+instance AttrInfo ButtonFocusOnClickPropertyInfo where+    type AttrAllowedOps ButtonFocusOnClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonFocusOnClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ButtonFocusOnClickPropertyInfo = ButtonK+    type AttrGetType ButtonFocusOnClickPropertyInfo = Bool+    type AttrLabel ButtonFocusOnClickPropertyInfo = "Button::focus-on-click"+    attrGet _ = getButtonFocusOnClick+    attrSet _ = setButtonFocusOnClick+    attrConstruct _ = constructButtonFocusOnClick++-- VVV Prop "image"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonImage :: (MonadIO m, ButtonK o) => o -> m Widget+getButtonImage obj = liftIO $ getObjectPropertyObject obj "image" Widget++setButtonImage :: (MonadIO m, ButtonK o, WidgetK a) => o -> a -> m ()+setButtonImage obj val = liftIO $ setObjectPropertyObject obj "image" val++constructButtonImage :: (WidgetK a) => a -> IO ([Char], GValue)+constructButtonImage val = constructObjectPropertyObject "image" val++data ButtonImagePropertyInfo+instance AttrInfo ButtonImagePropertyInfo where+    type AttrAllowedOps ButtonImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonImagePropertyInfo = WidgetK+    type AttrBaseTypeConstraint ButtonImagePropertyInfo = ButtonK+    type AttrGetType ButtonImagePropertyInfo = Widget+    type AttrLabel ButtonImagePropertyInfo = "Button::image"+    attrGet _ = getButtonImage+    attrSet _ = setButtonImage+    attrConstruct _ = constructButtonImage++-- VVV Prop "image-position"+   -- Type: TInterface "Gtk" "PositionType"+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonImagePosition :: (MonadIO m, ButtonK o) => o -> m PositionType+getButtonImagePosition obj = liftIO $ getObjectPropertyEnum obj "image-position"++setButtonImagePosition :: (MonadIO m, ButtonK o) => o -> PositionType -> m ()+setButtonImagePosition obj val = liftIO $ setObjectPropertyEnum obj "image-position" val++constructButtonImagePosition :: PositionType -> IO ([Char], GValue)+constructButtonImagePosition val = constructObjectPropertyEnum "image-position" val++data ButtonImagePositionPropertyInfo+instance AttrInfo ButtonImagePositionPropertyInfo where+    type AttrAllowedOps ButtonImagePositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonImagePositionPropertyInfo = (~) PositionType+    type AttrBaseTypeConstraint ButtonImagePositionPropertyInfo = ButtonK+    type AttrGetType ButtonImagePositionPropertyInfo = PositionType+    type AttrLabel ButtonImagePositionPropertyInfo = "Button::image-position"+    attrGet _ = getButtonImagePosition+    attrSet _ = setButtonImagePosition+    attrConstruct _ = constructButtonImagePosition++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getButtonLabel :: (MonadIO m, ButtonK o) => o -> m T.Text+getButtonLabel obj = liftIO $ getObjectPropertyString obj "label"++setButtonLabel :: (MonadIO m, ButtonK o) => o -> T.Text -> m ()+setButtonLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructButtonLabel :: T.Text -> IO ([Char], GValue)+constructButtonLabel val = constructObjectPropertyString "label" val++data ButtonLabelPropertyInfo+instance AttrInfo ButtonLabelPropertyInfo where+    type AttrAllowedOps ButtonLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ButtonLabelPropertyInfo = ButtonK+    type AttrGetType ButtonLabelPropertyInfo = T.Text+    type AttrLabel ButtonLabelPropertyInfo = "Button::label"+    attrGet _ = getButtonLabel+    attrSet _ = setButtonLabel+    attrConstruct _ = constructButtonLabel++-- VVV Prop "relief"+   -- Type: TInterface "Gtk" "ReliefStyle"+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonRelief :: (MonadIO m, ButtonK o) => o -> m ReliefStyle+getButtonRelief obj = liftIO $ getObjectPropertyEnum obj "relief"++setButtonRelief :: (MonadIO m, ButtonK o) => o -> ReliefStyle -> m ()+setButtonRelief obj val = liftIO $ setObjectPropertyEnum obj "relief" val++constructButtonRelief :: ReliefStyle -> IO ([Char], GValue)+constructButtonRelief val = constructObjectPropertyEnum "relief" val++data ButtonReliefPropertyInfo+instance AttrInfo ButtonReliefPropertyInfo where+    type AttrAllowedOps ButtonReliefPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonReliefPropertyInfo = (~) ReliefStyle+    type AttrBaseTypeConstraint ButtonReliefPropertyInfo = ButtonK+    type AttrGetType ButtonReliefPropertyInfo = ReliefStyle+    type AttrLabel ButtonReliefPropertyInfo = "Button::relief"+    attrGet _ = getButtonRelief+    attrSet _ = setButtonRelief+    attrConstruct _ = constructButtonRelief++-- VVV Prop "use-stock"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getButtonUseStock :: (MonadIO m, ButtonK o) => o -> m Bool+getButtonUseStock obj = liftIO $ getObjectPropertyBool obj "use-stock"++setButtonUseStock :: (MonadIO m, ButtonK o) => o -> Bool -> m ()+setButtonUseStock obj val = liftIO $ setObjectPropertyBool obj "use-stock" val++constructButtonUseStock :: Bool -> IO ([Char], GValue)+constructButtonUseStock val = constructObjectPropertyBool "use-stock" val++data ButtonUseStockPropertyInfo+instance AttrInfo ButtonUseStockPropertyInfo where+    type AttrAllowedOps ButtonUseStockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonUseStockPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ButtonUseStockPropertyInfo = ButtonK+    type AttrGetType ButtonUseStockPropertyInfo = Bool+    type AttrLabel ButtonUseStockPropertyInfo = "Button::use-stock"+    attrGet _ = getButtonUseStock+    attrSet _ = setButtonUseStock+    attrConstruct _ = constructButtonUseStock++-- VVV Prop "use-underline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getButtonUseUnderline :: (MonadIO m, ButtonK o) => o -> m Bool+getButtonUseUnderline obj = liftIO $ getObjectPropertyBool obj "use-underline"++setButtonUseUnderline :: (MonadIO m, ButtonK o) => o -> Bool -> m ()+setButtonUseUnderline obj val = liftIO $ setObjectPropertyBool obj "use-underline" val++constructButtonUseUnderline :: Bool -> IO ([Char], GValue)+constructButtonUseUnderline val = constructObjectPropertyBool "use-underline" val++data ButtonUseUnderlinePropertyInfo+instance AttrInfo ButtonUseUnderlinePropertyInfo where+    type AttrAllowedOps ButtonUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonUseUnderlinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ButtonUseUnderlinePropertyInfo = ButtonK+    type AttrGetType ButtonUseUnderlinePropertyInfo = Bool+    type AttrLabel ButtonUseUnderlinePropertyInfo = "Button::use-underline"+    attrGet _ = getButtonUseUnderline+    attrSet _ = setButtonUseUnderline+    attrConstruct _ = constructButtonUseUnderline++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonXalign :: (MonadIO m, ButtonK o) => o -> m Float+getButtonXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setButtonXalign :: (MonadIO m, ButtonK o) => o -> Float -> m ()+setButtonXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructButtonXalign :: Float -> IO ([Char], GValue)+constructButtonXalign val = constructObjectPropertyFloat "xalign" val++data ButtonXalignPropertyInfo+instance AttrInfo ButtonXalignPropertyInfo where+    type AttrAllowedOps ButtonXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint ButtonXalignPropertyInfo = ButtonK+    type AttrGetType ButtonXalignPropertyInfo = Float+    type AttrLabel ButtonXalignPropertyInfo = "Button::xalign"+    attrGet _ = getButtonXalign+    attrSet _ = setButtonXalign+    attrConstruct _ = constructButtonXalign++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonYalign :: (MonadIO m, ButtonK o) => o -> m Float+getButtonYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setButtonYalign :: (MonadIO m, ButtonK o) => o -> Float -> m ()+setButtonYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructButtonYalign :: Float -> IO ([Char], GValue)+constructButtonYalign val = constructObjectPropertyFloat "yalign" val++data ButtonYalignPropertyInfo+instance AttrInfo ButtonYalignPropertyInfo where+    type AttrAllowedOps ButtonYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint ButtonYalignPropertyInfo = ButtonK+    type AttrGetType ButtonYalignPropertyInfo = Float+    type AttrLabel ButtonYalignPropertyInfo = "Button::yalign"+    attrGet _ = getButtonYalign+    attrSet _ = setButtonYalign+    attrConstruct _ = constructButtonYalign++type instance AttributeList Button = ButtonAttributeList+type ButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++data ButtonActivateSignalInfo+instance SignalInfo ButtonActivateSignalInfo where+    type HaskellCallbackType ButtonActivateSignalInfo = ButtonActivateCallback+    connectSignal _ = connectButtonActivate++data ButtonClickedSignalInfo+instance SignalInfo ButtonClickedSignalInfo where+    type HaskellCallbackType ButtonClickedSignalInfo = ButtonClickedCallback+    connectSignal _ = connectButtonClicked++data ButtonEnterSignalInfo+instance SignalInfo ButtonEnterSignalInfo where+    type HaskellCallbackType ButtonEnterSignalInfo = ButtonEnterCallback+    connectSignal _ = connectButtonEnter++data ButtonLeaveSignalInfo+instance SignalInfo ButtonLeaveSignalInfo where+    type HaskellCallbackType ButtonLeaveSignalInfo = ButtonLeaveCallback+    connectSignal _ = connectButtonLeave++data ButtonPressedSignalInfo+instance SignalInfo ButtonPressedSignalInfo where+    type HaskellCallbackType ButtonPressedSignalInfo = ButtonPressedCallback+    connectSignal _ = connectButtonPressed++data ButtonReleasedSignalInfo+instance SignalInfo ButtonReleasedSignalInfo where+    type HaskellCallbackType ButtonReleasedSignalInfo = ButtonReleasedCallback+    connectSignal _ = connectButtonReleased++type instance SignalList Button = ButtonSignalList+type ButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Button::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_new" gtk_button_new :: +    IO (Ptr Button)+++buttonNew ::+    (MonadIO m) =>+    m Button+buttonNew  = liftIO $ do+    result <- gtk_button_new+    checkUnexpectedReturnNULL "gtk_button_new" result+    result' <- (newObject Button) result+    return result'++-- method Button::new_from_icon_name+-- method type : Constructor+-- Args : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_new_from_icon_name" gtk_button_new_from_icon_name :: +    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr Button)+++buttonNewFromIconName ::+    (MonadIO m) =>+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    m Button+buttonNewFromIconName icon_name size = liftIO $ do+    icon_name' <- textToCString icon_name+    result <- gtk_button_new_from_icon_name icon_name' size+    checkUnexpectedReturnNULL "gtk_button_new_from_icon_name" result+    result' <- (newObject Button) result+    freeMem icon_name'+    return result'++-- method Button::new_from_stock+-- method type : Constructor+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_new_from_stock" gtk_button_new_from_stock :: +    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr Button)++{-# DEPRECATED buttonNewFromStock ["(Since version 3.10)","Use gtk_button_new_with_label() instead."]#-}+buttonNewFromStock ::+    (MonadIO m) =>+    T.Text ->                               -- stock_id+    m Button+buttonNewFromStock stock_id = liftIO $ do+    stock_id' <- textToCString stock_id+    result <- gtk_button_new_from_stock stock_id'+    checkUnexpectedReturnNULL "gtk_button_new_from_stock" result+    result' <- (newObject Button) result+    freeMem stock_id'+    return result'++-- method Button::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_new_with_label" gtk_button_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Button)+++buttonNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m Button+buttonNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- gtk_button_new_with_label label'+    checkUnexpectedReturnNULL "gtk_button_new_with_label" result+    result' <- (newObject Button) result+    freeMem label'+    return result'++-- method Button::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_new_with_mnemonic" gtk_button_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Button)+++buttonNewWithMnemonic ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m Button+buttonNewWithMnemonic label = liftIO $ do+    label' <- textToCString label+    result <- gtk_button_new_with_mnemonic label'+    checkUnexpectedReturnNULL "gtk_button_new_with_mnemonic" result+    result' <- (newObject Button) result+    freeMem label'+    return result'++-- method Button::clicked+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_clicked" gtk_button_clicked :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO ()+++buttonClicked ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ()+buttonClicked _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_button_clicked _obj'+    touchManagedPtr _obj+    return ()++-- method Button::enter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_enter" gtk_button_enter :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO ()++{-# DEPRECATED buttonEnter ["(Since version 2.20)","Use the #GtkWidget::enter-notify-event signal."]#-}+buttonEnter ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ()+buttonEnter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_button_enter _obj'+    touchManagedPtr _obj+    return ()++-- method Button::get_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_alignment" gtk_button_get_alignment :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    Ptr CFloat ->                           -- xalign : TBasicType TFloat+    Ptr CFloat ->                           -- yalign : TBasicType TFloat+    IO ()++{-# DEPRECATED buttonGetAlignment ["(Since version 3.14)","Access the child widget directly if you need to control","its alignment."]#-}+buttonGetAlignment ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m (Float,Float)+buttonGetAlignment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xalign <- allocMem :: IO (Ptr CFloat)+    yalign <- allocMem :: IO (Ptr CFloat)+    gtk_button_get_alignment _obj' xalign yalign+    xalign' <- peek xalign+    let xalign'' = realToFrac xalign'+    yalign' <- peek yalign+    let yalign'' = realToFrac yalign'+    touchManagedPtr _obj+    freeMem xalign+    freeMem yalign+    return (xalign'', yalign'')++-- method Button::get_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_always_show_image" gtk_button_get_always_show_image :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CInt+++buttonGetAlwaysShowImage ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Bool+buttonGetAlwaysShowImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_always_show_image _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Button::get_event_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_event_window" gtk_button_get_event_window :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO (Ptr Gdk.Window)+++buttonGetEventWindow ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Gdk.Window+buttonGetEventWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_event_window _obj'+    checkUnexpectedReturnNULL "gtk_button_get_event_window" result+    result' <- (newObject Gdk.Window) result+    touchManagedPtr _obj+    return result'++-- method Button::get_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_focus_on_click" gtk_button_get_focus_on_click :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CInt+++buttonGetFocusOnClick ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Bool+buttonGetFocusOnClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_focus_on_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Button::get_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_image" gtk_button_get_image :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO (Ptr Widget)+++buttonGetImage ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Widget+buttonGetImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_image _obj'+    checkUnexpectedReturnNULL "gtk_button_get_image" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Button::get_image_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PositionType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_image_position" gtk_button_get_image_position :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CUInt+++buttonGetImagePosition ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m PositionType+buttonGetImagePosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_image_position _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Button::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_label" gtk_button_get_label :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CString+++buttonGetLabel ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m T.Text+buttonGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_label _obj'+    checkUnexpectedReturnNULL "gtk_button_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Button::get_relief+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ReliefStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_relief" gtk_button_get_relief :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CUInt+++buttonGetRelief ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ReliefStyle+buttonGetRelief _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_relief _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Button::get_use_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_use_stock" gtk_button_get_use_stock :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CInt++{-# DEPRECATED buttonGetUseStock ["(Since version 3.10)"]#-}+buttonGetUseStock ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Bool+buttonGetUseStock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_use_stock _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Button::get_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_get_use_underline" gtk_button_get_use_underline :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO CInt+++buttonGetUseUnderline ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m Bool+buttonGetUseUnderline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_get_use_underline _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Button::leave+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_leave" gtk_button_leave :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO ()++{-# DEPRECATED buttonLeave ["(Since version 2.20)","Use the #GtkWidget::leave-notify-event signal."]#-}+buttonLeave ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ()+buttonLeave _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_button_leave _obj'+    touchManagedPtr _obj+    return ()++-- method Button::pressed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_pressed" gtk_button_pressed :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO ()++{-# DEPRECATED buttonPressed ["(Since version 2.20)","Use the #GtkWidget::button-press-event signal."]#-}+buttonPressed ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ()+buttonPressed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_button_pressed _obj'+    touchManagedPtr _obj+    return ()++-- method Button::released+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_released" gtk_button_released :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    IO ()++{-# DEPRECATED buttonReleased ["(Since version 2.20)","Use the #GtkWidget::button-release-event signal."]#-}+buttonReleased ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    m ()+buttonReleased _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_button_released _obj'+    touchManagedPtr _obj+    return ()++-- method Button::set_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_set_alignment" gtk_button_set_alignment :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    IO ()++{-# DEPRECATED buttonSetAlignment ["(Since version 3.14)","Access the child widget directly if you need to control","its alignment."]#-}+buttonSetAlignment ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    m ()+buttonSetAlignment _obj xalign yalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    gtk_button_set_alignment _obj' xalign' yalign'+    touchManagedPtr _obj+    return ()++-- method Button::set_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", 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 "gtk_button_set_always_show_image" gtk_button_set_always_show_image :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CInt ->                                 -- always_show : TBasicType TBoolean+    IO ()+++buttonSetAlwaysShowImage ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- always_show+    m ()+buttonSetAlwaysShowImage _obj always_show = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let always_show' = (fromIntegral . fromEnum) always_show+    gtk_button_set_always_show_image _obj' always_show'+    touchManagedPtr _obj+    return ()++-- method Button::set_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", 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 "gtk_button_set_focus_on_click" gtk_button_set_focus_on_click :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CInt ->                                 -- focus_on_click : TBasicType TBoolean+    IO ()+++buttonSetFocusOnClick ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- focus_on_click+    m ()+buttonSetFocusOnClick _obj focus_on_click = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let focus_on_click' = (fromIntegral . fromEnum) focus_on_click+    gtk_button_set_focus_on_click _obj' focus_on_click'+    touchManagedPtr _obj+    return ()++-- method Button::set_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_set_image" gtk_button_set_image :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    Ptr Widget ->                           -- image : TInterface "Gtk" "Widget"+    IO ()+++buttonSetImage ::+    (MonadIO m, ButtonK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- image+    m ()+buttonSetImage _obj image = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let image' = unsafeManagedPtrCastPtr image+    gtk_button_set_image _obj' image'+    touchManagedPtr _obj+    touchManagedPtr image+    return ()++-- method Button::set_image_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_set_image_position" gtk_button_set_image_position :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CUInt ->                                -- position : TInterface "Gtk" "PositionType"+    IO ()+++buttonSetImagePosition ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    PositionType ->                         -- position+    m ()+buttonSetImagePosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let position' = (fromIntegral . fromEnum) position+    gtk_button_set_image_position _obj' position'+    touchManagedPtr _obj+    return ()++-- method Button::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_set_label" gtk_button_set_label :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++buttonSetLabel ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    m ()+buttonSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    gtk_button_set_label _obj' label'+    touchManagedPtr _obj+    freeMem label'+    return ()++-- method Button::set_relief+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relief", argType = TInterface "Gtk" "ReliefStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relief", argType = TInterface "Gtk" "ReliefStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_set_relief" gtk_button_set_relief :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CUInt ->                                -- relief : TInterface "Gtk" "ReliefStyle"+    IO ()+++buttonSetRelief ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    ReliefStyle ->                          -- relief+    m ()+buttonSetRelief _obj relief = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let relief' = (fromIntegral . fromEnum) relief+    gtk_button_set_relief _obj' relief'+    touchManagedPtr _obj+    return ()++-- method Button::set_use_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_stock", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_stock", 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 "gtk_button_set_use_stock" gtk_button_set_use_stock :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CInt ->                                 -- use_stock : TBasicType TBoolean+    IO ()++{-# DEPRECATED buttonSetUseStock ["(Since version 3.10)"]#-}+buttonSetUseStock ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_stock+    m ()+buttonSetUseStock _obj use_stock = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_stock' = (fromIntegral . fromEnum) use_stock+    gtk_button_set_use_stock _obj' use_stock'+    touchManagedPtr _obj+    return ()++-- method Button::set_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_underline", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Button", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_underline", 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 "gtk_button_set_use_underline" gtk_button_set_use_underline :: +    Ptr Button ->                           -- _obj : TInterface "Gtk" "Button"+    CInt ->                                 -- use_underline : TBasicType TBoolean+    IO ()+++buttonSetUseUnderline ::+    (MonadIO m, ButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_underline+    m ()+buttonSetUseUnderline _obj use_underline = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_underline' = (fromIntegral . fromEnum) use_underline+    gtk_button_set_use_underline _obj' use_underline'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Button.hs-boot view
@@ -0,0 +1,29 @@+module GI.Gtk.Objects.Button where++import Prelude ()+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 Button = Button (ForeignPtr Button)+instance GObject Button where+class GObject o => ButtonK o+instance (GObject o, IsDescendantOf Button o) => ButtonK o+data ButtonAlwaysShowImagePropertyInfo+data ButtonFocusOnClickPropertyInfo+data ButtonImagePropertyInfo+data ButtonImagePositionPropertyInfo+data ButtonLabelPropertyInfo+data ButtonReliefPropertyInfo+data ButtonUseStockPropertyInfo+data ButtonUseUnderlinePropertyInfo+data ButtonXalignPropertyInfo+data ButtonYalignPropertyInfo+data ButtonActivateSignalInfo+data ButtonClickedSignalInfo+data ButtonEnterSignalInfo+data ButtonLeaveSignalInfo+data ButtonPressedSignalInfo+data ButtonReleasedSignalInfo
+ GI/Gtk/Objects/ButtonAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ButtonAccessible+    ( ++-- * Exported types+    ButtonAccessible(..)                    ,+    ButtonAccessibleK                       ,+    toButtonAccessible                      ,+    noButtonAccessible                      ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ButtonAccessible = ButtonAccessible (ForeignPtr ButtonAccessible)+foreign import ccall "gtk_button_accessible_get_type"+    c_gtk_button_accessible_get_type :: IO GType++type instance ParentTypes ButtonAccessible = ButtonAccessibleParentTypes+type ButtonAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Image]++instance GObject ButtonAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_button_accessible_get_type+    ++class GObject o => ButtonAccessibleK o+instance (GObject o, IsDescendantOf ButtonAccessible o) => ButtonAccessibleK o++toButtonAccessible :: ButtonAccessibleK o => o -> IO ButtonAccessible+toButtonAccessible = unsafeCastTo ButtonAccessible++noButtonAccessible :: Maybe ButtonAccessible+noButtonAccessible = Nothing++type instance AttributeList ButtonAccessible = ButtonAccessibleAttributeList+type ButtonAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ButtonAccessible = ButtonAccessibleSignalList+type ButtonAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ButtonAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ButtonAccessible where++import Prelude ()+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 ButtonAccessible = ButtonAccessible (ForeignPtr ButtonAccessible)+instance GObject ButtonAccessible where+class GObject o => ButtonAccessibleK o+instance (GObject o, IsDescendantOf ButtonAccessible o) => ButtonAccessibleK o
+ GI/Gtk/Objects/ButtonBox.hs view
@@ -0,0 +1,321 @@++{- |+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.Gtk.Objects.ButtonBox+    ( ++-- * Exported types+    ButtonBox(..)                           ,+    ButtonBoxK                              ,+    toButtonBox                             ,+    noButtonBox                             ,+++ -- * Methods+-- ** buttonBoxGetChildNonHomogeneous+    buttonBoxGetChildNonHomogeneous         ,+++-- ** buttonBoxGetChildSecondary+    buttonBoxGetChildSecondary              ,+++-- ** buttonBoxGetLayout+    buttonBoxGetLayout                      ,+++-- ** buttonBoxNew+    buttonBoxNew                            ,+++-- ** buttonBoxSetChildNonHomogeneous+    buttonBoxSetChildNonHomogeneous         ,+++-- ** buttonBoxSetChildSecondary+    buttonBoxSetChildSecondary              ,+++-- ** buttonBoxSetLayout+    buttonBoxSetLayout                      ,+++++ -- * Properties+-- ** LayoutStyle+    ButtonBoxLayoutStylePropertyInfo        ,+    constructButtonBoxLayoutStyle           ,+    getButtonBoxLayoutStyle                 ,+    setButtonBoxLayoutStyle                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ButtonBox = ButtonBox (ForeignPtr ButtonBox)+foreign import ccall "gtk_button_box_get_type"+    c_gtk_button_box_get_type :: IO GType++type instance ParentTypes ButtonBox = ButtonBoxParentTypes+type ButtonBoxParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject ButtonBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_button_box_get_type+    ++class GObject o => ButtonBoxK o+instance (GObject o, IsDescendantOf ButtonBox o) => ButtonBoxK o++toButtonBox :: ButtonBoxK o => o -> IO ButtonBox+toButtonBox = unsafeCastTo ButtonBox++noButtonBox :: Maybe ButtonBox+noButtonBox = Nothing++-- VVV Prop "layout-style"+   -- Type: TInterface "Gtk" "ButtonBoxStyle"+   -- Flags: [PropertyReadable,PropertyWritable]++getButtonBoxLayoutStyle :: (MonadIO m, ButtonBoxK o) => o -> m ButtonBoxStyle+getButtonBoxLayoutStyle obj = liftIO $ getObjectPropertyEnum obj "layout-style"++setButtonBoxLayoutStyle :: (MonadIO m, ButtonBoxK o) => o -> ButtonBoxStyle -> m ()+setButtonBoxLayoutStyle obj val = liftIO $ setObjectPropertyEnum obj "layout-style" val++constructButtonBoxLayoutStyle :: ButtonBoxStyle -> IO ([Char], GValue)+constructButtonBoxLayoutStyle val = constructObjectPropertyEnum "layout-style" val++data ButtonBoxLayoutStylePropertyInfo+instance AttrInfo ButtonBoxLayoutStylePropertyInfo where+    type AttrAllowedOps ButtonBoxLayoutStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ButtonBoxLayoutStylePropertyInfo = (~) ButtonBoxStyle+    type AttrBaseTypeConstraint ButtonBoxLayoutStylePropertyInfo = ButtonBoxK+    type AttrGetType ButtonBoxLayoutStylePropertyInfo = ButtonBoxStyle+    type AttrLabel ButtonBoxLayoutStylePropertyInfo = "ButtonBox::layout-style"+    attrGet _ = getButtonBoxLayoutStyle+    attrSet _ = setButtonBoxLayoutStyle+    attrConstruct _ = constructButtonBoxLayoutStyle++type instance AttributeList ButtonBox = ButtonBoxAttributeList+type ButtonBoxAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("layout-style", ButtonBoxLayoutStylePropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ButtonBox = ButtonBoxSignalList+type ButtonBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ButtonBox::new+-- method type : Constructor+-- Args : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ButtonBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_box_new" gtk_button_box_new :: +    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO (Ptr ButtonBox)+++buttonBoxNew ::+    (MonadIO m) =>+    Orientation ->                          -- orientation+    m ButtonBox+buttonBoxNew orientation = liftIO $ do+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- gtk_button_box_new orientation'+    checkUnexpectedReturnNULL "gtk_button_box_new" result+    result' <- (newObject ButtonBox) result+    return result'++-- method ButtonBox::get_child_non_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_box_get_child_non_homogeneous" gtk_button_box_get_child_non_homogeneous :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CInt+++buttonBoxGetChildNonHomogeneous ::+    (MonadIO m, ButtonBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Bool+buttonBoxGetChildNonHomogeneous _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_button_box_get_child_non_homogeneous _obj' child'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method ButtonBox::get_child_secondary+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_box_get_child_secondary" gtk_button_box_get_child_secondary :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CInt+++buttonBoxGetChildSecondary ::+    (MonadIO m, ButtonBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Bool+buttonBoxGetChildSecondary _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_button_box_get_child_secondary _obj' child'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method ButtonBox::get_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ButtonBoxStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_box_get_layout" gtk_button_box_get_layout :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    IO CUInt+++buttonBoxGetLayout ::+    (MonadIO m, ButtonBoxK a) =>+    a ->                                    -- _obj+    m ButtonBoxStyle+buttonBoxGetLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_button_box_get_layout _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ButtonBox::set_child_non_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "non_homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "non_homogeneous", 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 "gtk_button_box_set_child_non_homogeneous" gtk_button_box_set_child_non_homogeneous :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- non_homogeneous : TBasicType TBoolean+    IO ()+++buttonBoxSetChildNonHomogeneous ::+    (MonadIO m, ButtonBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- non_homogeneous+    m ()+buttonBoxSetChildNonHomogeneous _obj child non_homogeneous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let non_homogeneous' = (fromIntegral . fromEnum) non_homogeneous+    gtk_button_box_set_child_non_homogeneous _obj' child' non_homogeneous'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ButtonBox::set_child_secondary+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_secondary", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_secondary", 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 "gtk_button_box_set_child_secondary" gtk_button_box_set_child_secondary :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- is_secondary : TBasicType TBoolean+    IO ()+++buttonBoxSetChildSecondary ::+    (MonadIO m, ButtonBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- is_secondary+    m ()+buttonBoxSetChildSecondary _obj child is_secondary = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let is_secondary' = (fromIntegral . fromEnum) is_secondary+    gtk_button_box_set_child_secondary _obj' child' is_secondary'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ButtonBox::set_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout_style", argType = TInterface "Gtk" "ButtonBoxStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ButtonBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout_style", argType = TInterface "Gtk" "ButtonBoxStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_button_box_set_layout" gtk_button_box_set_layout :: +    Ptr ButtonBox ->                        -- _obj : TInterface "Gtk" "ButtonBox"+    CUInt ->                                -- layout_style : TInterface "Gtk" "ButtonBoxStyle"+    IO ()+++buttonBoxSetLayout ::+    (MonadIO m, ButtonBoxK a) =>+    a ->                                    -- _obj+    ButtonBoxStyle ->                       -- layout_style+    m ()+buttonBoxSetLayout _obj layout_style = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let layout_style' = (fromIntegral . fromEnum) layout_style+    gtk_button_box_set_layout _obj' layout_style'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ButtonBox.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.ButtonBox where++import Prelude ()+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 ButtonBox = ButtonBox (ForeignPtr ButtonBox)+instance GObject ButtonBox where+class GObject o => ButtonBoxK o+instance (GObject o, IsDescendantOf ButtonBox o) => ButtonBoxK o+data ButtonBoxLayoutStylePropertyInfo
+ GI/Gtk/Objects/Calendar.hs view
@@ -0,0 +1,1222 @@++{- |+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.Gtk.Objects.Calendar+    ( ++-- * Exported types+    Calendar(..)                            ,+    CalendarK                               ,+    toCalendar                              ,+    noCalendar                              ,+++ -- * Methods+-- ** calendarClearMarks+    calendarClearMarks                      ,+++-- ** calendarGetDate+    calendarGetDate                         ,+++-- ** calendarGetDayIsMarked+    calendarGetDayIsMarked                  ,+++-- ** calendarGetDetailHeightRows+    calendarGetDetailHeightRows             ,+++-- ** calendarGetDetailWidthChars+    calendarGetDetailWidthChars             ,+++-- ** calendarGetDisplayOptions+    calendarGetDisplayOptions               ,+++-- ** calendarMarkDay+    calendarMarkDay                         ,+++-- ** calendarNew+    calendarNew                             ,+++-- ** calendarSelectDay+    calendarSelectDay                       ,+++-- ** calendarSelectMonth+    calendarSelectMonth                     ,+++-- ** calendarSetDetailFunc+    calendarSetDetailFunc                   ,+++-- ** calendarSetDetailHeightRows+    calendarSetDetailHeightRows             ,+++-- ** calendarSetDetailWidthChars+    calendarSetDetailWidthChars             ,+++-- ** calendarSetDisplayOptions+    calendarSetDisplayOptions               ,+++-- ** calendarUnmarkDay+    calendarUnmarkDay                       ,+++++ -- * Properties+-- ** Day+    CalendarDayPropertyInfo                 ,+    constructCalendarDay                    ,+    getCalendarDay                          ,+    setCalendarDay                          ,+++-- ** DetailHeightRows+    CalendarDetailHeightRowsPropertyInfo    ,+    constructCalendarDetailHeightRows       ,+    getCalendarDetailHeightRows             ,+    setCalendarDetailHeightRows             ,+++-- ** DetailWidthChars+    CalendarDetailWidthCharsPropertyInfo    ,+    constructCalendarDetailWidthChars       ,+    getCalendarDetailWidthChars             ,+    setCalendarDetailWidthChars             ,+++-- ** Month+    CalendarMonthPropertyInfo               ,+    constructCalendarMonth                  ,+    getCalendarMonth                        ,+    setCalendarMonth                        ,+++-- ** NoMonthChange+    CalendarNoMonthChangePropertyInfo       ,+    constructCalendarNoMonthChange          ,+    getCalendarNoMonthChange                ,+    setCalendarNoMonthChange                ,+++-- ** ShowDayNames+    CalendarShowDayNamesPropertyInfo        ,+    constructCalendarShowDayNames           ,+    getCalendarShowDayNames                 ,+    setCalendarShowDayNames                 ,+++-- ** ShowDetails+    CalendarShowDetailsPropertyInfo         ,+    constructCalendarShowDetails            ,+    getCalendarShowDetails                  ,+    setCalendarShowDetails                  ,+++-- ** ShowHeading+    CalendarShowHeadingPropertyInfo         ,+    constructCalendarShowHeading            ,+    getCalendarShowHeading                  ,+    setCalendarShowHeading                  ,+++-- ** ShowWeekNumbers+    CalendarShowWeekNumbersPropertyInfo     ,+    constructCalendarShowWeekNumbers        ,+    getCalendarShowWeekNumbers              ,+    setCalendarShowWeekNumbers              ,+++-- ** Year+    CalendarYearPropertyInfo                ,+    constructCalendarYear                   ,+    getCalendarYear                         ,+    setCalendarYear                         ,+++++ -- * Signals+-- ** DaySelected+    CalendarDaySelectedCallback             ,+    CalendarDaySelectedCallbackC            ,+    CalendarDaySelectedSignalInfo           ,+    afterCalendarDaySelected                ,+    calendarDaySelectedCallbackWrapper      ,+    calendarDaySelectedClosure              ,+    mkCalendarDaySelectedCallback           ,+    noCalendarDaySelectedCallback           ,+    onCalendarDaySelected                   ,+++-- ** DaySelectedDoubleClick+    CalendarDaySelectedDoubleClickCallback  ,+    CalendarDaySelectedDoubleClickCallbackC ,+    CalendarDaySelectedDoubleClickSignalInfo,+    afterCalendarDaySelectedDoubleClick     ,+    calendarDaySelectedDoubleClickCallbackWrapper,+    calendarDaySelectedDoubleClickClosure   ,+    mkCalendarDaySelectedDoubleClickCallback,+    noCalendarDaySelectedDoubleClickCallback,+    onCalendarDaySelectedDoubleClick        ,+++-- ** MonthChanged+    CalendarMonthChangedCallback            ,+    CalendarMonthChangedCallbackC           ,+    CalendarMonthChangedSignalInfo          ,+    afterCalendarMonthChanged               ,+    calendarMonthChangedCallbackWrapper     ,+    calendarMonthChangedClosure             ,+    mkCalendarMonthChangedCallback          ,+    noCalendarMonthChangedCallback          ,+    onCalendarMonthChanged                  ,+++-- ** NextMonth+    CalendarNextMonthCallback               ,+    CalendarNextMonthCallbackC              ,+    CalendarNextMonthSignalInfo             ,+    afterCalendarNextMonth                  ,+    calendarNextMonthCallbackWrapper        ,+    calendarNextMonthClosure                ,+    mkCalendarNextMonthCallback             ,+    noCalendarNextMonthCallback             ,+    onCalendarNextMonth                     ,+++-- ** NextYear+    CalendarNextYearCallback                ,+    CalendarNextYearCallbackC               ,+    CalendarNextYearSignalInfo              ,+    afterCalendarNextYear                   ,+    calendarNextYearCallbackWrapper         ,+    calendarNextYearClosure                 ,+    mkCalendarNextYearCallback              ,+    noCalendarNextYearCallback              ,+    onCalendarNextYear                      ,+++-- ** PrevMonth+    CalendarPrevMonthCallback               ,+    CalendarPrevMonthCallbackC              ,+    CalendarPrevMonthSignalInfo             ,+    afterCalendarPrevMonth                  ,+    calendarPrevMonthCallbackWrapper        ,+    calendarPrevMonthClosure                ,+    mkCalendarPrevMonthCallback             ,+    noCalendarPrevMonthCallback             ,+    onCalendarPrevMonth                     ,+++-- ** PrevYear+    CalendarPrevYearCallback                ,+    CalendarPrevYearCallbackC               ,+    CalendarPrevYearSignalInfo              ,+    afterCalendarPrevYear                   ,+    calendarPrevYearCallbackWrapper         ,+    calendarPrevYearClosure                 ,+    mkCalendarPrevYearCallback              ,+    noCalendarPrevYearCallback              ,+    onCalendarPrevYear                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Calendar = Calendar (ForeignPtr Calendar)+foreign import ccall "gtk_calendar_get_type"+    c_gtk_calendar_get_type :: IO GType++type instance ParentTypes Calendar = CalendarParentTypes+type CalendarParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Calendar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_calendar_get_type+    ++class GObject o => CalendarK o+instance (GObject o, IsDescendantOf Calendar o) => CalendarK o++toCalendar :: CalendarK o => o -> IO Calendar+toCalendar = unsafeCastTo Calendar++noCalendar :: Maybe Calendar+noCalendar = Nothing++-- signal Calendar::day-selected+type CalendarDaySelectedCallback =+    IO ()++noCalendarDaySelectedCallback :: Maybe CalendarDaySelectedCallback+noCalendarDaySelectedCallback = Nothing++type CalendarDaySelectedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarDaySelectedCallback :: CalendarDaySelectedCallbackC -> IO (FunPtr CalendarDaySelectedCallbackC)++calendarDaySelectedClosure :: CalendarDaySelectedCallback -> IO Closure+calendarDaySelectedClosure cb = newCClosure =<< mkCalendarDaySelectedCallback wrapped+    where wrapped = calendarDaySelectedCallbackWrapper cb++calendarDaySelectedCallbackWrapper ::+    CalendarDaySelectedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarDaySelectedCallbackWrapper _cb _ _ = do+    _cb ++onCalendarDaySelected :: (GObject a, MonadIO m) => a -> CalendarDaySelectedCallback -> m SignalHandlerId+onCalendarDaySelected obj cb = liftIO $ connectCalendarDaySelected obj cb SignalConnectBefore+afterCalendarDaySelected :: (GObject a, MonadIO m) => a -> CalendarDaySelectedCallback -> m SignalHandlerId+afterCalendarDaySelected obj cb = connectCalendarDaySelected obj cb SignalConnectAfter++connectCalendarDaySelected :: (GObject a, MonadIO m) =>+                              a -> CalendarDaySelectedCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarDaySelected obj cb after = liftIO $ do+    cb' <- mkCalendarDaySelectedCallback (calendarDaySelectedCallbackWrapper cb)+    connectSignalFunPtr obj "day-selected" cb' after++-- signal Calendar::day-selected-double-click+type CalendarDaySelectedDoubleClickCallback =+    IO ()++noCalendarDaySelectedDoubleClickCallback :: Maybe CalendarDaySelectedDoubleClickCallback+noCalendarDaySelectedDoubleClickCallback = Nothing++type CalendarDaySelectedDoubleClickCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarDaySelectedDoubleClickCallback :: CalendarDaySelectedDoubleClickCallbackC -> IO (FunPtr CalendarDaySelectedDoubleClickCallbackC)++calendarDaySelectedDoubleClickClosure :: CalendarDaySelectedDoubleClickCallback -> IO Closure+calendarDaySelectedDoubleClickClosure cb = newCClosure =<< mkCalendarDaySelectedDoubleClickCallback wrapped+    where wrapped = calendarDaySelectedDoubleClickCallbackWrapper cb++calendarDaySelectedDoubleClickCallbackWrapper ::+    CalendarDaySelectedDoubleClickCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarDaySelectedDoubleClickCallbackWrapper _cb _ _ = do+    _cb ++onCalendarDaySelectedDoubleClick :: (GObject a, MonadIO m) => a -> CalendarDaySelectedDoubleClickCallback -> m SignalHandlerId+onCalendarDaySelectedDoubleClick obj cb = liftIO $ connectCalendarDaySelectedDoubleClick obj cb SignalConnectBefore+afterCalendarDaySelectedDoubleClick :: (GObject a, MonadIO m) => a -> CalendarDaySelectedDoubleClickCallback -> m SignalHandlerId+afterCalendarDaySelectedDoubleClick obj cb = connectCalendarDaySelectedDoubleClick obj cb SignalConnectAfter++connectCalendarDaySelectedDoubleClick :: (GObject a, MonadIO m) =>+                                         a -> CalendarDaySelectedDoubleClickCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarDaySelectedDoubleClick obj cb after = liftIO $ do+    cb' <- mkCalendarDaySelectedDoubleClickCallback (calendarDaySelectedDoubleClickCallbackWrapper cb)+    connectSignalFunPtr obj "day-selected-double-click" cb' after++-- signal Calendar::month-changed+type CalendarMonthChangedCallback =+    IO ()++noCalendarMonthChangedCallback :: Maybe CalendarMonthChangedCallback+noCalendarMonthChangedCallback = Nothing++type CalendarMonthChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarMonthChangedCallback :: CalendarMonthChangedCallbackC -> IO (FunPtr CalendarMonthChangedCallbackC)++calendarMonthChangedClosure :: CalendarMonthChangedCallback -> IO Closure+calendarMonthChangedClosure cb = newCClosure =<< mkCalendarMonthChangedCallback wrapped+    where wrapped = calendarMonthChangedCallbackWrapper cb++calendarMonthChangedCallbackWrapper ::+    CalendarMonthChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarMonthChangedCallbackWrapper _cb _ _ = do+    _cb ++onCalendarMonthChanged :: (GObject a, MonadIO m) => a -> CalendarMonthChangedCallback -> m SignalHandlerId+onCalendarMonthChanged obj cb = liftIO $ connectCalendarMonthChanged obj cb SignalConnectBefore+afterCalendarMonthChanged :: (GObject a, MonadIO m) => a -> CalendarMonthChangedCallback -> m SignalHandlerId+afterCalendarMonthChanged obj cb = connectCalendarMonthChanged obj cb SignalConnectAfter++connectCalendarMonthChanged :: (GObject a, MonadIO m) =>+                               a -> CalendarMonthChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarMonthChanged obj cb after = liftIO $ do+    cb' <- mkCalendarMonthChangedCallback (calendarMonthChangedCallbackWrapper cb)+    connectSignalFunPtr obj "month-changed" cb' after++-- signal Calendar::next-month+type CalendarNextMonthCallback =+    IO ()++noCalendarNextMonthCallback :: Maybe CalendarNextMonthCallback+noCalendarNextMonthCallback = Nothing++type CalendarNextMonthCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarNextMonthCallback :: CalendarNextMonthCallbackC -> IO (FunPtr CalendarNextMonthCallbackC)++calendarNextMonthClosure :: CalendarNextMonthCallback -> IO Closure+calendarNextMonthClosure cb = newCClosure =<< mkCalendarNextMonthCallback wrapped+    where wrapped = calendarNextMonthCallbackWrapper cb++calendarNextMonthCallbackWrapper ::+    CalendarNextMonthCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarNextMonthCallbackWrapper _cb _ _ = do+    _cb ++onCalendarNextMonth :: (GObject a, MonadIO m) => a -> CalendarNextMonthCallback -> m SignalHandlerId+onCalendarNextMonth obj cb = liftIO $ connectCalendarNextMonth obj cb SignalConnectBefore+afterCalendarNextMonth :: (GObject a, MonadIO m) => a -> CalendarNextMonthCallback -> m SignalHandlerId+afterCalendarNextMonth obj cb = connectCalendarNextMonth obj cb SignalConnectAfter++connectCalendarNextMonth :: (GObject a, MonadIO m) =>+                            a -> CalendarNextMonthCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarNextMonth obj cb after = liftIO $ do+    cb' <- mkCalendarNextMonthCallback (calendarNextMonthCallbackWrapper cb)+    connectSignalFunPtr obj "next-month" cb' after++-- signal Calendar::next-year+type CalendarNextYearCallback =+    IO ()++noCalendarNextYearCallback :: Maybe CalendarNextYearCallback+noCalendarNextYearCallback = Nothing++type CalendarNextYearCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarNextYearCallback :: CalendarNextYearCallbackC -> IO (FunPtr CalendarNextYearCallbackC)++calendarNextYearClosure :: CalendarNextYearCallback -> IO Closure+calendarNextYearClosure cb = newCClosure =<< mkCalendarNextYearCallback wrapped+    where wrapped = calendarNextYearCallbackWrapper cb++calendarNextYearCallbackWrapper ::+    CalendarNextYearCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarNextYearCallbackWrapper _cb _ _ = do+    _cb ++onCalendarNextYear :: (GObject a, MonadIO m) => a -> CalendarNextYearCallback -> m SignalHandlerId+onCalendarNextYear obj cb = liftIO $ connectCalendarNextYear obj cb SignalConnectBefore+afterCalendarNextYear :: (GObject a, MonadIO m) => a -> CalendarNextYearCallback -> m SignalHandlerId+afterCalendarNextYear obj cb = connectCalendarNextYear obj cb SignalConnectAfter++connectCalendarNextYear :: (GObject a, MonadIO m) =>+                           a -> CalendarNextYearCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarNextYear obj cb after = liftIO $ do+    cb' <- mkCalendarNextYearCallback (calendarNextYearCallbackWrapper cb)+    connectSignalFunPtr obj "next-year" cb' after++-- signal Calendar::prev-month+type CalendarPrevMonthCallback =+    IO ()++noCalendarPrevMonthCallback :: Maybe CalendarPrevMonthCallback+noCalendarPrevMonthCallback = Nothing++type CalendarPrevMonthCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarPrevMonthCallback :: CalendarPrevMonthCallbackC -> IO (FunPtr CalendarPrevMonthCallbackC)++calendarPrevMonthClosure :: CalendarPrevMonthCallback -> IO Closure+calendarPrevMonthClosure cb = newCClosure =<< mkCalendarPrevMonthCallback wrapped+    where wrapped = calendarPrevMonthCallbackWrapper cb++calendarPrevMonthCallbackWrapper ::+    CalendarPrevMonthCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarPrevMonthCallbackWrapper _cb _ _ = do+    _cb ++onCalendarPrevMonth :: (GObject a, MonadIO m) => a -> CalendarPrevMonthCallback -> m SignalHandlerId+onCalendarPrevMonth obj cb = liftIO $ connectCalendarPrevMonth obj cb SignalConnectBefore+afterCalendarPrevMonth :: (GObject a, MonadIO m) => a -> CalendarPrevMonthCallback -> m SignalHandlerId+afterCalendarPrevMonth obj cb = connectCalendarPrevMonth obj cb SignalConnectAfter++connectCalendarPrevMonth :: (GObject a, MonadIO m) =>+                            a -> CalendarPrevMonthCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarPrevMonth obj cb after = liftIO $ do+    cb' <- mkCalendarPrevMonthCallback (calendarPrevMonthCallbackWrapper cb)+    connectSignalFunPtr obj "prev-month" cb' after++-- signal Calendar::prev-year+type CalendarPrevYearCallback =+    IO ()++noCalendarPrevYearCallback :: Maybe CalendarPrevYearCallback+noCalendarPrevYearCallback = Nothing++type CalendarPrevYearCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCalendarPrevYearCallback :: CalendarPrevYearCallbackC -> IO (FunPtr CalendarPrevYearCallbackC)++calendarPrevYearClosure :: CalendarPrevYearCallback -> IO Closure+calendarPrevYearClosure cb = newCClosure =<< mkCalendarPrevYearCallback wrapped+    where wrapped = calendarPrevYearCallbackWrapper cb++calendarPrevYearCallbackWrapper ::+    CalendarPrevYearCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+calendarPrevYearCallbackWrapper _cb _ _ = do+    _cb ++onCalendarPrevYear :: (GObject a, MonadIO m) => a -> CalendarPrevYearCallback -> m SignalHandlerId+onCalendarPrevYear obj cb = liftIO $ connectCalendarPrevYear obj cb SignalConnectBefore+afterCalendarPrevYear :: (GObject a, MonadIO m) => a -> CalendarPrevYearCallback -> m SignalHandlerId+afterCalendarPrevYear obj cb = connectCalendarPrevYear obj cb SignalConnectAfter++connectCalendarPrevYear :: (GObject a, MonadIO m) =>+                           a -> CalendarPrevYearCallback -> SignalConnectMode -> m SignalHandlerId+connectCalendarPrevYear obj cb after = liftIO $ do+    cb' <- mkCalendarPrevYearCallback (calendarPrevYearCallbackWrapper cb)+    connectSignalFunPtr obj "prev-year" cb' after++-- VVV Prop "day"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarDay :: (MonadIO m, CalendarK o) => o -> m Int32+getCalendarDay obj = liftIO $ getObjectPropertyCInt obj "day"++setCalendarDay :: (MonadIO m, CalendarK o) => o -> Int32 -> m ()+setCalendarDay obj val = liftIO $ setObjectPropertyCInt obj "day" val++constructCalendarDay :: Int32 -> IO ([Char], GValue)+constructCalendarDay val = constructObjectPropertyCInt "day" val++data CalendarDayPropertyInfo+instance AttrInfo CalendarDayPropertyInfo where+    type AttrAllowedOps CalendarDayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarDayPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CalendarDayPropertyInfo = CalendarK+    type AttrGetType CalendarDayPropertyInfo = Int32+    type AttrLabel CalendarDayPropertyInfo = "Calendar::day"+    attrGet _ = getCalendarDay+    attrSet _ = setCalendarDay+    attrConstruct _ = constructCalendarDay++-- VVV Prop "detail-height-rows"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarDetailHeightRows :: (MonadIO m, CalendarK o) => o -> m Int32+getCalendarDetailHeightRows obj = liftIO $ getObjectPropertyCInt obj "detail-height-rows"++setCalendarDetailHeightRows :: (MonadIO m, CalendarK o) => o -> Int32 -> m ()+setCalendarDetailHeightRows obj val = liftIO $ setObjectPropertyCInt obj "detail-height-rows" val++constructCalendarDetailHeightRows :: Int32 -> IO ([Char], GValue)+constructCalendarDetailHeightRows val = constructObjectPropertyCInt "detail-height-rows" val++data CalendarDetailHeightRowsPropertyInfo+instance AttrInfo CalendarDetailHeightRowsPropertyInfo where+    type AttrAllowedOps CalendarDetailHeightRowsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarDetailHeightRowsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CalendarDetailHeightRowsPropertyInfo = CalendarK+    type AttrGetType CalendarDetailHeightRowsPropertyInfo = Int32+    type AttrLabel CalendarDetailHeightRowsPropertyInfo = "Calendar::detail-height-rows"+    attrGet _ = getCalendarDetailHeightRows+    attrSet _ = setCalendarDetailHeightRows+    attrConstruct _ = constructCalendarDetailHeightRows++-- VVV Prop "detail-width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarDetailWidthChars :: (MonadIO m, CalendarK o) => o -> m Int32+getCalendarDetailWidthChars obj = liftIO $ getObjectPropertyCInt obj "detail-width-chars"++setCalendarDetailWidthChars :: (MonadIO m, CalendarK o) => o -> Int32 -> m ()+setCalendarDetailWidthChars obj val = liftIO $ setObjectPropertyCInt obj "detail-width-chars" val++constructCalendarDetailWidthChars :: Int32 -> IO ([Char], GValue)+constructCalendarDetailWidthChars val = constructObjectPropertyCInt "detail-width-chars" val++data CalendarDetailWidthCharsPropertyInfo+instance AttrInfo CalendarDetailWidthCharsPropertyInfo where+    type AttrAllowedOps CalendarDetailWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarDetailWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CalendarDetailWidthCharsPropertyInfo = CalendarK+    type AttrGetType CalendarDetailWidthCharsPropertyInfo = Int32+    type AttrLabel CalendarDetailWidthCharsPropertyInfo = "Calendar::detail-width-chars"+    attrGet _ = getCalendarDetailWidthChars+    attrSet _ = setCalendarDetailWidthChars+    attrConstruct _ = constructCalendarDetailWidthChars++-- VVV Prop "month"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarMonth :: (MonadIO m, CalendarK o) => o -> m Int32+getCalendarMonth obj = liftIO $ getObjectPropertyCInt obj "month"++setCalendarMonth :: (MonadIO m, CalendarK o) => o -> Int32 -> m ()+setCalendarMonth obj val = liftIO $ setObjectPropertyCInt obj "month" val++constructCalendarMonth :: Int32 -> IO ([Char], GValue)+constructCalendarMonth val = constructObjectPropertyCInt "month" val++data CalendarMonthPropertyInfo+instance AttrInfo CalendarMonthPropertyInfo where+    type AttrAllowedOps CalendarMonthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarMonthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CalendarMonthPropertyInfo = CalendarK+    type AttrGetType CalendarMonthPropertyInfo = Int32+    type AttrLabel CalendarMonthPropertyInfo = "Calendar::month"+    attrGet _ = getCalendarMonth+    attrSet _ = setCalendarMonth+    attrConstruct _ = constructCalendarMonth++-- VVV Prop "no-month-change"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarNoMonthChange :: (MonadIO m, CalendarK o) => o -> m Bool+getCalendarNoMonthChange obj = liftIO $ getObjectPropertyBool obj "no-month-change"++setCalendarNoMonthChange :: (MonadIO m, CalendarK o) => o -> Bool -> m ()+setCalendarNoMonthChange obj val = liftIO $ setObjectPropertyBool obj "no-month-change" val++constructCalendarNoMonthChange :: Bool -> IO ([Char], GValue)+constructCalendarNoMonthChange val = constructObjectPropertyBool "no-month-change" val++data CalendarNoMonthChangePropertyInfo+instance AttrInfo CalendarNoMonthChangePropertyInfo where+    type AttrAllowedOps CalendarNoMonthChangePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarNoMonthChangePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CalendarNoMonthChangePropertyInfo = CalendarK+    type AttrGetType CalendarNoMonthChangePropertyInfo = Bool+    type AttrLabel CalendarNoMonthChangePropertyInfo = "Calendar::no-month-change"+    attrGet _ = getCalendarNoMonthChange+    attrSet _ = setCalendarNoMonthChange+    attrConstruct _ = constructCalendarNoMonthChange++-- VVV Prop "show-day-names"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarShowDayNames :: (MonadIO m, CalendarK o) => o -> m Bool+getCalendarShowDayNames obj = liftIO $ getObjectPropertyBool obj "show-day-names"++setCalendarShowDayNames :: (MonadIO m, CalendarK o) => o -> Bool -> m ()+setCalendarShowDayNames obj val = liftIO $ setObjectPropertyBool obj "show-day-names" val++constructCalendarShowDayNames :: Bool -> IO ([Char], GValue)+constructCalendarShowDayNames val = constructObjectPropertyBool "show-day-names" val++data CalendarShowDayNamesPropertyInfo+instance AttrInfo CalendarShowDayNamesPropertyInfo where+    type AttrAllowedOps CalendarShowDayNamesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarShowDayNamesPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CalendarShowDayNamesPropertyInfo = CalendarK+    type AttrGetType CalendarShowDayNamesPropertyInfo = Bool+    type AttrLabel CalendarShowDayNamesPropertyInfo = "Calendar::show-day-names"+    attrGet _ = getCalendarShowDayNames+    attrSet _ = setCalendarShowDayNames+    attrConstruct _ = constructCalendarShowDayNames++-- VVV Prop "show-details"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarShowDetails :: (MonadIO m, CalendarK o) => o -> m Bool+getCalendarShowDetails obj = liftIO $ getObjectPropertyBool obj "show-details"++setCalendarShowDetails :: (MonadIO m, CalendarK o) => o -> Bool -> m ()+setCalendarShowDetails obj val = liftIO $ setObjectPropertyBool obj "show-details" val++constructCalendarShowDetails :: Bool -> IO ([Char], GValue)+constructCalendarShowDetails val = constructObjectPropertyBool "show-details" val++data CalendarShowDetailsPropertyInfo+instance AttrInfo CalendarShowDetailsPropertyInfo where+    type AttrAllowedOps CalendarShowDetailsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarShowDetailsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CalendarShowDetailsPropertyInfo = CalendarK+    type AttrGetType CalendarShowDetailsPropertyInfo = Bool+    type AttrLabel CalendarShowDetailsPropertyInfo = "Calendar::show-details"+    attrGet _ = getCalendarShowDetails+    attrSet _ = setCalendarShowDetails+    attrConstruct _ = constructCalendarShowDetails++-- VVV Prop "show-heading"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarShowHeading :: (MonadIO m, CalendarK o) => o -> m Bool+getCalendarShowHeading obj = liftIO $ getObjectPropertyBool obj "show-heading"++setCalendarShowHeading :: (MonadIO m, CalendarK o) => o -> Bool -> m ()+setCalendarShowHeading obj val = liftIO $ setObjectPropertyBool obj "show-heading" val++constructCalendarShowHeading :: Bool -> IO ([Char], GValue)+constructCalendarShowHeading val = constructObjectPropertyBool "show-heading" val++data CalendarShowHeadingPropertyInfo+instance AttrInfo CalendarShowHeadingPropertyInfo where+    type AttrAllowedOps CalendarShowHeadingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarShowHeadingPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CalendarShowHeadingPropertyInfo = CalendarK+    type AttrGetType CalendarShowHeadingPropertyInfo = Bool+    type AttrLabel CalendarShowHeadingPropertyInfo = "Calendar::show-heading"+    attrGet _ = getCalendarShowHeading+    attrSet _ = setCalendarShowHeading+    attrConstruct _ = constructCalendarShowHeading++-- VVV Prop "show-week-numbers"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarShowWeekNumbers :: (MonadIO m, CalendarK o) => o -> m Bool+getCalendarShowWeekNumbers obj = liftIO $ getObjectPropertyBool obj "show-week-numbers"++setCalendarShowWeekNumbers :: (MonadIO m, CalendarK o) => o -> Bool -> m ()+setCalendarShowWeekNumbers obj val = liftIO $ setObjectPropertyBool obj "show-week-numbers" val++constructCalendarShowWeekNumbers :: Bool -> IO ([Char], GValue)+constructCalendarShowWeekNumbers val = constructObjectPropertyBool "show-week-numbers" val++data CalendarShowWeekNumbersPropertyInfo+instance AttrInfo CalendarShowWeekNumbersPropertyInfo where+    type AttrAllowedOps CalendarShowWeekNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarShowWeekNumbersPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CalendarShowWeekNumbersPropertyInfo = CalendarK+    type AttrGetType CalendarShowWeekNumbersPropertyInfo = Bool+    type AttrLabel CalendarShowWeekNumbersPropertyInfo = "Calendar::show-week-numbers"+    attrGet _ = getCalendarShowWeekNumbers+    attrSet _ = setCalendarShowWeekNumbers+    attrConstruct _ = constructCalendarShowWeekNumbers++-- VVV Prop "year"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCalendarYear :: (MonadIO m, CalendarK o) => o -> m Int32+getCalendarYear obj = liftIO $ getObjectPropertyCInt obj "year"++setCalendarYear :: (MonadIO m, CalendarK o) => o -> Int32 -> m ()+setCalendarYear obj val = liftIO $ setObjectPropertyCInt obj "year" val++constructCalendarYear :: Int32 -> IO ([Char], GValue)+constructCalendarYear val = constructObjectPropertyCInt "year" val++data CalendarYearPropertyInfo+instance AttrInfo CalendarYearPropertyInfo where+    type AttrAllowedOps CalendarYearPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CalendarYearPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CalendarYearPropertyInfo = CalendarK+    type AttrGetType CalendarYearPropertyInfo = Int32+    type AttrLabel CalendarYearPropertyInfo = "Calendar::year"+    attrGet _ = getCalendarYear+    attrSet _ = setCalendarYear+    attrConstruct _ = constructCalendarYear++type instance AttributeList Calendar = CalendarAttributeList+type CalendarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("day", CalendarDayPropertyInfo), '("detail-height-rows", CalendarDetailHeightRowsPropertyInfo), '("detail-width-chars", CalendarDetailWidthCharsPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("month", CalendarMonthPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-month-change", CalendarNoMonthChangePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-day-names", CalendarShowDayNamesPropertyInfo), '("show-details", CalendarShowDetailsPropertyInfo), '("show-heading", CalendarShowHeadingPropertyInfo), '("show-week-numbers", CalendarShowWeekNumbersPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("year", CalendarYearPropertyInfo)] :: [(Symbol, *)])++data CalendarDaySelectedSignalInfo+instance SignalInfo CalendarDaySelectedSignalInfo where+    type HaskellCallbackType CalendarDaySelectedSignalInfo = CalendarDaySelectedCallback+    connectSignal _ = connectCalendarDaySelected++data CalendarDaySelectedDoubleClickSignalInfo+instance SignalInfo CalendarDaySelectedDoubleClickSignalInfo where+    type HaskellCallbackType CalendarDaySelectedDoubleClickSignalInfo = CalendarDaySelectedDoubleClickCallback+    connectSignal _ = connectCalendarDaySelectedDoubleClick++data CalendarMonthChangedSignalInfo+instance SignalInfo CalendarMonthChangedSignalInfo where+    type HaskellCallbackType CalendarMonthChangedSignalInfo = CalendarMonthChangedCallback+    connectSignal _ = connectCalendarMonthChanged++data CalendarNextMonthSignalInfo+instance SignalInfo CalendarNextMonthSignalInfo where+    type HaskellCallbackType CalendarNextMonthSignalInfo = CalendarNextMonthCallback+    connectSignal _ = connectCalendarNextMonth++data CalendarNextYearSignalInfo+instance SignalInfo CalendarNextYearSignalInfo where+    type HaskellCallbackType CalendarNextYearSignalInfo = CalendarNextYearCallback+    connectSignal _ = connectCalendarNextYear++data CalendarPrevMonthSignalInfo+instance SignalInfo CalendarPrevMonthSignalInfo where+    type HaskellCallbackType CalendarPrevMonthSignalInfo = CalendarPrevMonthCallback+    connectSignal _ = connectCalendarPrevMonth++data CalendarPrevYearSignalInfo+instance SignalInfo CalendarPrevYearSignalInfo where+    type HaskellCallbackType CalendarPrevYearSignalInfo = CalendarPrevYearCallback+    connectSignal _ = connectCalendarPrevYear++type instance SignalList Calendar = CalendarSignalList+type CalendarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("day-selected", CalendarDaySelectedSignalInfo), '("day-selected-double-click", CalendarDaySelectedDoubleClickSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("month-changed", CalendarMonthChangedSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("next-month", CalendarNextMonthSignalInfo), '("next-year", CalendarNextYearSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("prev-month", CalendarPrevMonthSignalInfo), '("prev-year", CalendarPrevYearSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Calendar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Calendar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_new" gtk_calendar_new :: +    IO (Ptr Calendar)+++calendarNew ::+    (MonadIO m) =>+    m Calendar+calendarNew  = liftIO $ do+    result <- gtk_calendar_new+    checkUnexpectedReturnNULL "gtk_calendar_new" result+    result' <- (newObject Calendar) result+    return result'++-- method Calendar::clear_marks+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_clear_marks" gtk_calendar_clear_marks :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    IO ()+++calendarClearMarks ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    m ()+calendarClearMarks _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_clear_marks _obj'+    touchManagedPtr _obj+    return ()++-- method Calendar::get_date+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "year", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "month", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "day", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_get_date" gtk_calendar_get_date :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Ptr Word32 ->                           -- year : TBasicType TUInt32+    Ptr Word32 ->                           -- month : TBasicType TUInt32+    Ptr Word32 ->                           -- day : TBasicType TUInt32+    IO ()+++calendarGetDate ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    m (Word32,Word32,Word32)+calendarGetDate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    year <- allocMem :: IO (Ptr Word32)+    month <- allocMem :: IO (Ptr Word32)+    day <- allocMem :: IO (Ptr Word32)+    gtk_calendar_get_date _obj' year month day+    year' <- peek year+    month' <- peek month+    day' <- peek day+    touchManagedPtr _obj+    freeMem year+    freeMem month+    freeMem day+    return (year', month', day')++-- method Calendar::get_day_is_marked+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", 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 "gtk_calendar_get_day_is_marked" gtk_calendar_get_day_is_marked :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Word32 ->                               -- day : TBasicType TUInt32+    IO CInt+++calendarGetDayIsMarked ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- day+    m Bool+calendarGetDayIsMarked _obj day = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_calendar_get_day_is_marked _obj' day+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Calendar::get_detail_height_rows+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_get_detail_height_rows" gtk_calendar_get_detail_height_rows :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    IO Int32+++calendarGetDetailHeightRows ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    m Int32+calendarGetDetailHeightRows _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_calendar_get_detail_height_rows _obj'+    touchManagedPtr _obj+    return result++-- method Calendar::get_detail_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_get_detail_width_chars" gtk_calendar_get_detail_width_chars :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    IO Int32+++calendarGetDetailWidthChars ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    m Int32+calendarGetDetailWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_calendar_get_detail_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method Calendar::get_display_options+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CalendarDisplayOptions"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_get_display_options" gtk_calendar_get_display_options :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    IO CUInt+++calendarGetDisplayOptions ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    m [CalendarDisplayOptions]+calendarGetDisplayOptions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_calendar_get_display_options _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Calendar::mark_day+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", 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 "gtk_calendar_mark_day" gtk_calendar_mark_day :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Word32 ->                               -- day : TBasicType TUInt32+    IO ()+++calendarMarkDay ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- day+    m ()+calendarMarkDay _obj day = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_mark_day _obj' day+    touchManagedPtr _obj+    return ()++-- method Calendar::select_day+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", 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 "gtk_calendar_select_day" gtk_calendar_select_day :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Word32 ->                               -- day : TBasicType TUInt32+    IO ()+++calendarSelectDay ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- day+    m ()+calendarSelectDay _obj day = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_select_day _obj' day+    touchManagedPtr _obj+    return ()++-- method Calendar::select_month+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "month", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "year", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "month", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "year", 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 "gtk_calendar_select_month" gtk_calendar_select_month :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Word32 ->                               -- month : TBasicType TUInt32+    Word32 ->                               -- year : TBasicType TUInt32+    IO ()+++calendarSelectMonth ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- month+    Word32 ->                               -- year+    m ()+calendarSelectMonth _obj month year = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_select_month _obj' month year+    touchManagedPtr _obj+    return ()++-- method Calendar::set_detail_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "CalendarDetailFunc", 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 = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "CalendarDetailFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_set_detail_func" gtk_calendar_set_detail_func :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    FunPtr CalendarDetailFuncC ->           -- func : TInterface "Gtk" "CalendarDetailFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++calendarSetDetailFunc ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    CalendarDetailFunc ->                   -- func+    m ()+calendarSetDetailFunc _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkCalendarDetailFunc (calendarDetailFuncWrapper Nothing func)+    let data_ = castFunPtrToPtr func'+    let destroy = safeFreeFunPtrPtr+    gtk_calendar_set_detail_func _obj' func' data_ destroy+    touchManagedPtr _obj+    return ()++-- method Calendar::set_detail_height_rows+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rows", 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 "gtk_calendar_set_detail_height_rows" gtk_calendar_set_detail_height_rows :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Int32 ->                                -- rows : TBasicType TInt32+    IO ()+++calendarSetDetailHeightRows ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- rows+    m ()+calendarSetDetailHeightRows _obj rows = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_set_detail_height_rows _obj' rows+    touchManagedPtr _obj+    return ()++-- method Calendar::set_detail_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chars", 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 "gtk_calendar_set_detail_width_chars" gtk_calendar_set_detail_width_chars :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Int32 ->                                -- chars : TBasicType TInt32+    IO ()+++calendarSetDetailWidthChars ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- chars+    m ()+calendarSetDetailWidthChars _obj chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_set_detail_width_chars _obj' chars+    touchManagedPtr _obj+    return ()++-- method Calendar::set_display_options+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CalendarDisplayOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CalendarDisplayOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_calendar_set_display_options" gtk_calendar_set_display_options :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    CUInt ->                                -- flags : TInterface "Gtk" "CalendarDisplayOptions"+    IO ()+++calendarSetDisplayOptions ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    [CalendarDisplayOptions] ->             -- flags+    m ()+calendarSetDisplayOptions _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    gtk_calendar_set_display_options _obj' flags'+    touchManagedPtr _obj+    return ()++-- method Calendar::unmark_day+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Calendar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "day", 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 "gtk_calendar_unmark_day" gtk_calendar_unmark_day :: +    Ptr Calendar ->                         -- _obj : TInterface "Gtk" "Calendar"+    Word32 ->                               -- day : TBasicType TUInt32+    IO ()+++calendarUnmarkDay ::+    (MonadIO m, CalendarK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- day+    m ()+calendarUnmarkDay _obj day = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_calendar_unmark_day _obj' day+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Calendar.hs-boot view
@@ -0,0 +1,30 @@+module GI.Gtk.Objects.Calendar where++import Prelude ()+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 Calendar = Calendar (ForeignPtr Calendar)+instance GObject Calendar where+class GObject o => CalendarK o+instance (GObject o, IsDescendantOf Calendar o) => CalendarK o+data CalendarDayPropertyInfo+data CalendarDetailHeightRowsPropertyInfo+data CalendarDetailWidthCharsPropertyInfo+data CalendarMonthPropertyInfo+data CalendarNoMonthChangePropertyInfo+data CalendarShowDayNamesPropertyInfo+data CalendarShowDetailsPropertyInfo+data CalendarShowHeadingPropertyInfo+data CalendarShowWeekNumbersPropertyInfo+data CalendarYearPropertyInfo+data CalendarDaySelectedSignalInfo+data CalendarDaySelectedDoubleClickSignalInfo+data CalendarMonthChangedSignalInfo+data CalendarNextMonthSignalInfo+data CalendarNextYearSignalInfo+data CalendarPrevMonthSignalInfo+data CalendarPrevYearSignalInfo
+ GI/Gtk/Objects/CellAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.CellAccessible+    ( ++-- * Exported types+    CellAccessible(..)                      ,+    CellAccessibleK                         ,+    toCellAccessible                        ,+    noCellAccessible                        ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype CellAccessible = CellAccessible (ForeignPtr CellAccessible)+foreign import ccall "gtk_cell_accessible_get_type"+    c_gtk_cell_accessible_get_type :: IO GType++type instance ParentTypes CellAccessible = CellAccessibleParentTypes+type CellAccessibleParentTypes = '[Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component]++instance GObject CellAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_cell_accessible_get_type+    ++class GObject o => CellAccessibleK o+instance (GObject o, IsDescendantOf CellAccessible o) => CellAccessibleK o++toCellAccessible :: CellAccessibleK o => o -> IO CellAccessible+toCellAccessible = unsafeCastTo CellAccessible++noCellAccessible :: Maybe CellAccessible+noCellAccessible = Nothing++type instance AttributeList CellAccessible = CellAccessibleAttributeList+type CellAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellAccessible = CellAccessibleSignalList+type CellAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/CellAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.CellAccessible where++import Prelude ()+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 CellAccessible = CellAccessible (ForeignPtr CellAccessible)+instance GObject CellAccessible where+class GObject o => CellAccessibleK o+instance (GObject o, IsDescendantOf CellAccessible o) => CellAccessibleK o
+ GI/Gtk/Objects/CellArea.hs view
@@ -0,0 +1,1902 @@++{- |+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.Gtk.Objects.CellArea+    ( ++-- * Exported types+    CellArea(..)                            ,+    CellAreaK                               ,+    toCellArea                              ,+    noCellArea                              ,+++ -- * Methods+-- ** cellAreaActivate+    cellAreaActivate                        ,+++-- ** cellAreaActivateCell+    cellAreaActivateCell                    ,+++-- ** cellAreaAdd+    cellAreaAdd                             ,+++-- ** cellAreaAddFocusSibling+    cellAreaAddFocusSibling                 ,+++-- ** cellAreaApplyAttributes+    cellAreaApplyAttributes                 ,+++-- ** cellAreaAttributeConnect+    cellAreaAttributeConnect                ,+++-- ** cellAreaAttributeDisconnect+    cellAreaAttributeDisconnect             ,+++-- ** cellAreaAttributeGetColumn+    cellAreaAttributeGetColumn              ,+++-- ** cellAreaCellGetProperty+    cellAreaCellGetProperty                 ,+++-- ** cellAreaCellSetProperty+    cellAreaCellSetProperty                 ,+++-- ** cellAreaCopyContext+    cellAreaCopyContext                     ,+++-- ** cellAreaCreateContext+    cellAreaCreateContext                   ,+++-- ** cellAreaEvent+    cellAreaEvent                           ,+++-- ** cellAreaFocus+    cellAreaFocus                           ,+++-- ** cellAreaForeach+    cellAreaForeach                         ,+++-- ** cellAreaForeachAlloc+    cellAreaForeachAlloc                    ,+++-- ** cellAreaGetCellAllocation+    cellAreaGetCellAllocation               ,+++-- ** cellAreaGetCellAtPosition+    cellAreaGetCellAtPosition               ,+++-- ** cellAreaGetCurrentPathString+    cellAreaGetCurrentPathString            ,+++-- ** cellAreaGetEditWidget+    cellAreaGetEditWidget                   ,+++-- ** cellAreaGetEditedCell+    cellAreaGetEditedCell                   ,+++-- ** cellAreaGetFocusCell+    cellAreaGetFocusCell                    ,+++-- ** cellAreaGetFocusFromSibling+    cellAreaGetFocusFromSibling             ,+++-- ** cellAreaGetFocusSiblings+    cellAreaGetFocusSiblings                ,+++-- ** cellAreaGetPreferredHeight+    cellAreaGetPreferredHeight              ,+++-- ** cellAreaGetPreferredHeightForWidth+    cellAreaGetPreferredHeightForWidth      ,+++-- ** cellAreaGetPreferredWidth+    cellAreaGetPreferredWidth               ,+++-- ** cellAreaGetPreferredWidthForHeight+    cellAreaGetPreferredWidthForHeight      ,+++-- ** cellAreaGetRequestMode+    cellAreaGetRequestMode                  ,+++-- ** cellAreaHasRenderer+    cellAreaHasRenderer                     ,+++-- ** cellAreaInnerCellArea+    cellAreaInnerCellArea                   ,+++-- ** cellAreaIsActivatable+    cellAreaIsActivatable                   ,+++-- ** cellAreaIsFocusSibling+    cellAreaIsFocusSibling                  ,+++-- ** cellAreaRemove+    cellAreaRemove                          ,+++-- ** cellAreaRemoveFocusSibling+    cellAreaRemoveFocusSibling              ,+++-- ** cellAreaRender+    cellAreaRender                          ,+++-- ** cellAreaRequestRenderer+    cellAreaRequestRenderer                 ,+++-- ** cellAreaSetFocusCell+    cellAreaSetFocusCell                    ,+++-- ** cellAreaStopEditing+    cellAreaStopEditing                     ,+++++ -- * Properties+-- ** EditWidget+    CellAreaEditWidgetPropertyInfo          ,+    getCellAreaEditWidget                   ,+++-- ** EditedCell+    CellAreaEditedCellPropertyInfo          ,+    getCellAreaEditedCell                   ,+++-- ** FocusCell+    CellAreaFocusCellPropertyInfo           ,+    constructCellAreaFocusCell              ,+    getCellAreaFocusCell                    ,+    setCellAreaFocusCell                    ,+++++ -- * Signals+-- ** AddEditable+    CellAreaAddEditableCallback             ,+    CellAreaAddEditableCallbackC            ,+    CellAreaAddEditableSignalInfo           ,+    afterCellAreaAddEditable                ,+    cellAreaAddEditableCallbackWrapper      ,+    cellAreaAddEditableClosure              ,+    mkCellAreaAddEditableCallback           ,+    noCellAreaAddEditableCallback           ,+    onCellAreaAddEditable                   ,+++-- ** ApplyAttributes+    CellAreaApplyAttributesCallback         ,+    CellAreaApplyAttributesCallbackC        ,+    CellAreaApplyAttributesSignalInfo       ,+    afterCellAreaApplyAttributes            ,+    cellAreaApplyAttributesCallbackWrapper  ,+    cellAreaApplyAttributesClosure          ,+    mkCellAreaApplyAttributesCallback       ,+    noCellAreaApplyAttributesCallback       ,+    onCellAreaApplyAttributes               ,+++-- ** FocusChanged+    CellAreaFocusChangedCallback            ,+    CellAreaFocusChangedCallbackC           ,+    CellAreaFocusChangedSignalInfo          ,+    afterCellAreaFocusChanged               ,+    cellAreaFocusChangedCallbackWrapper     ,+    cellAreaFocusChangedClosure             ,+    mkCellAreaFocusChangedCallback          ,+    noCellAreaFocusChangedCallback          ,+    onCellAreaFocusChanged                  ,+++-- ** RemoveEditable+    CellAreaRemoveEditableCallback          ,+    CellAreaRemoveEditableCallbackC         ,+    CellAreaRemoveEditableSignalInfo        ,+    afterCellAreaRemoveEditable             ,+    cellAreaRemoveEditableCallbackWrapper   ,+    cellAreaRemoveEditableClosure           ,+    mkCellAreaRemoveEditableCallback        ,+    noCellAreaRemoveEditableCallback        ,+    onCellAreaRemoveEditable                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Cairo as Cairo++newtype CellArea = CellArea (ForeignPtr CellArea)+foreign import ccall "gtk_cell_area_get_type"+    c_gtk_cell_area_get_type :: IO GType++type instance ParentTypes CellArea = CellAreaParentTypes+type CellAreaParentTypes = '[GObject.Object, Buildable, CellLayout]++instance GObject CellArea where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_area_get_type+    ++class GObject o => CellAreaK o+instance (GObject o, IsDescendantOf CellArea o) => CellAreaK o++toCellArea :: CellAreaK o => o -> IO CellArea+toCellArea = unsafeCastTo CellArea++noCellArea :: Maybe CellArea+noCellArea = Nothing++-- signal CellArea::add-editable+type CellAreaAddEditableCallback =+    CellRenderer ->+    CellEditable ->+    Gdk.Rectangle ->+    T.Text ->+    IO ()++noCellAreaAddEditableCallback :: Maybe CellAreaAddEditableCallback+noCellAreaAddEditableCallback = Nothing++type CellAreaAddEditableCallbackC =+    Ptr () ->                               -- object+    Ptr CellRenderer ->+    Ptr CellEditable ->+    Ptr Gdk.Rectangle ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellAreaAddEditableCallback :: CellAreaAddEditableCallbackC -> IO (FunPtr CellAreaAddEditableCallbackC)++cellAreaAddEditableClosure :: CellAreaAddEditableCallback -> IO Closure+cellAreaAddEditableClosure cb = newCClosure =<< mkCellAreaAddEditableCallback wrapped+    where wrapped = cellAreaAddEditableCallbackWrapper cb++cellAreaAddEditableCallbackWrapper ::+    CellAreaAddEditableCallback ->+    Ptr () ->+    Ptr CellRenderer ->+    Ptr CellEditable ->+    Ptr Gdk.Rectangle ->+    CString ->+    Ptr () ->+    IO ()+cellAreaAddEditableCallbackWrapper _cb _ renderer editable cell_area path _ = do+    renderer' <- (newObject CellRenderer) renderer+    editable' <- (newObject CellEditable) editable+    cell_area' <- (newBoxed Gdk.Rectangle) cell_area+    path' <- cstringToText path+    _cb  renderer' editable' cell_area' path'++onCellAreaAddEditable :: (GObject a, MonadIO m) => a -> CellAreaAddEditableCallback -> m SignalHandlerId+onCellAreaAddEditable obj cb = liftIO $ connectCellAreaAddEditable obj cb SignalConnectBefore+afterCellAreaAddEditable :: (GObject a, MonadIO m) => a -> CellAreaAddEditableCallback -> m SignalHandlerId+afterCellAreaAddEditable obj cb = connectCellAreaAddEditable obj cb SignalConnectAfter++connectCellAreaAddEditable :: (GObject a, MonadIO m) =>+                              a -> CellAreaAddEditableCallback -> SignalConnectMode -> m SignalHandlerId+connectCellAreaAddEditable obj cb after = liftIO $ do+    cb' <- mkCellAreaAddEditableCallback (cellAreaAddEditableCallbackWrapper cb)+    connectSignalFunPtr obj "add-editable" cb' after++-- signal CellArea::apply-attributes+type CellAreaApplyAttributesCallback =+    TreeModel ->+    TreeIter ->+    Bool ->+    Bool ->+    IO ()++noCellAreaApplyAttributesCallback :: Maybe CellAreaApplyAttributesCallback+noCellAreaApplyAttributesCallback = Nothing++type CellAreaApplyAttributesCallbackC =+    Ptr () ->                               -- object+    Ptr TreeModel ->+    Ptr TreeIter ->+    CInt ->+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellAreaApplyAttributesCallback :: CellAreaApplyAttributesCallbackC -> IO (FunPtr CellAreaApplyAttributesCallbackC)++cellAreaApplyAttributesClosure :: CellAreaApplyAttributesCallback -> IO Closure+cellAreaApplyAttributesClosure cb = newCClosure =<< mkCellAreaApplyAttributesCallback wrapped+    where wrapped = cellAreaApplyAttributesCallbackWrapper cb++cellAreaApplyAttributesCallbackWrapper ::+    CellAreaApplyAttributesCallback ->+    Ptr () ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    CInt ->+    CInt ->+    Ptr () ->+    IO ()+cellAreaApplyAttributesCallbackWrapper _cb _ model iter is_expander is_expanded _ = do+    model' <- (newObject TreeModel) model+    iter' <- (newBoxed TreeIter) iter+    let is_expander' = (/= 0) is_expander+    let is_expanded' = (/= 0) is_expanded+    _cb  model' iter' is_expander' is_expanded'++onCellAreaApplyAttributes :: (GObject a, MonadIO m) => a -> CellAreaApplyAttributesCallback -> m SignalHandlerId+onCellAreaApplyAttributes obj cb = liftIO $ connectCellAreaApplyAttributes obj cb SignalConnectBefore+afterCellAreaApplyAttributes :: (GObject a, MonadIO m) => a -> CellAreaApplyAttributesCallback -> m SignalHandlerId+afterCellAreaApplyAttributes obj cb = connectCellAreaApplyAttributes obj cb SignalConnectAfter++connectCellAreaApplyAttributes :: (GObject a, MonadIO m) =>+                                  a -> CellAreaApplyAttributesCallback -> SignalConnectMode -> m SignalHandlerId+connectCellAreaApplyAttributes obj cb after = liftIO $ do+    cb' <- mkCellAreaApplyAttributesCallback (cellAreaApplyAttributesCallbackWrapper cb)+    connectSignalFunPtr obj "apply-attributes" cb' after++-- signal CellArea::focus-changed+type CellAreaFocusChangedCallback =+    CellRenderer ->+    T.Text ->+    IO ()++noCellAreaFocusChangedCallback :: Maybe CellAreaFocusChangedCallback+noCellAreaFocusChangedCallback = Nothing++type CellAreaFocusChangedCallbackC =+    Ptr () ->                               -- object+    Ptr CellRenderer ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellAreaFocusChangedCallback :: CellAreaFocusChangedCallbackC -> IO (FunPtr CellAreaFocusChangedCallbackC)++cellAreaFocusChangedClosure :: CellAreaFocusChangedCallback -> IO Closure+cellAreaFocusChangedClosure cb = newCClosure =<< mkCellAreaFocusChangedCallback wrapped+    where wrapped = cellAreaFocusChangedCallbackWrapper cb++cellAreaFocusChangedCallbackWrapper ::+    CellAreaFocusChangedCallback ->+    Ptr () ->+    Ptr CellRenderer ->+    CString ->+    Ptr () ->+    IO ()+cellAreaFocusChangedCallbackWrapper _cb _ renderer path _ = do+    renderer' <- (newObject CellRenderer) renderer+    path' <- cstringToText path+    _cb  renderer' path'++onCellAreaFocusChanged :: (GObject a, MonadIO m) => a -> CellAreaFocusChangedCallback -> m SignalHandlerId+onCellAreaFocusChanged obj cb = liftIO $ connectCellAreaFocusChanged obj cb SignalConnectBefore+afterCellAreaFocusChanged :: (GObject a, MonadIO m) => a -> CellAreaFocusChangedCallback -> m SignalHandlerId+afterCellAreaFocusChanged obj cb = connectCellAreaFocusChanged obj cb SignalConnectAfter++connectCellAreaFocusChanged :: (GObject a, MonadIO m) =>+                               a -> CellAreaFocusChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellAreaFocusChanged obj cb after = liftIO $ do+    cb' <- mkCellAreaFocusChangedCallback (cellAreaFocusChangedCallbackWrapper cb)+    connectSignalFunPtr obj "focus-changed" cb' after++-- signal CellArea::remove-editable+type CellAreaRemoveEditableCallback =+    CellRenderer ->+    CellEditable ->+    IO ()++noCellAreaRemoveEditableCallback :: Maybe CellAreaRemoveEditableCallback+noCellAreaRemoveEditableCallback = Nothing++type CellAreaRemoveEditableCallbackC =+    Ptr () ->                               -- object+    Ptr CellRenderer ->+    Ptr CellEditable ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellAreaRemoveEditableCallback :: CellAreaRemoveEditableCallbackC -> IO (FunPtr CellAreaRemoveEditableCallbackC)++cellAreaRemoveEditableClosure :: CellAreaRemoveEditableCallback -> IO Closure+cellAreaRemoveEditableClosure cb = newCClosure =<< mkCellAreaRemoveEditableCallback wrapped+    where wrapped = cellAreaRemoveEditableCallbackWrapper cb++cellAreaRemoveEditableCallbackWrapper ::+    CellAreaRemoveEditableCallback ->+    Ptr () ->+    Ptr CellRenderer ->+    Ptr CellEditable ->+    Ptr () ->+    IO ()+cellAreaRemoveEditableCallbackWrapper _cb _ renderer editable _ = do+    renderer' <- (newObject CellRenderer) renderer+    editable' <- (newObject CellEditable) editable+    _cb  renderer' editable'++onCellAreaRemoveEditable :: (GObject a, MonadIO m) => a -> CellAreaRemoveEditableCallback -> m SignalHandlerId+onCellAreaRemoveEditable obj cb = liftIO $ connectCellAreaRemoveEditable obj cb SignalConnectBefore+afterCellAreaRemoveEditable :: (GObject a, MonadIO m) => a -> CellAreaRemoveEditableCallback -> m SignalHandlerId+afterCellAreaRemoveEditable obj cb = connectCellAreaRemoveEditable obj cb SignalConnectAfter++connectCellAreaRemoveEditable :: (GObject a, MonadIO m) =>+                                 a -> CellAreaRemoveEditableCallback -> SignalConnectMode -> m SignalHandlerId+connectCellAreaRemoveEditable obj cb after = liftIO $ do+    cb' <- mkCellAreaRemoveEditableCallback (cellAreaRemoveEditableCallbackWrapper cb)+    connectSignalFunPtr obj "remove-editable" cb' after++-- VVV Prop "edit-widget"+   -- Type: TInterface "Gtk" "CellEditable"+   -- Flags: [PropertyReadable]++getCellAreaEditWidget :: (MonadIO m, CellAreaK o) => o -> m CellEditable+getCellAreaEditWidget obj = liftIO $ getObjectPropertyObject obj "edit-widget" CellEditable++data CellAreaEditWidgetPropertyInfo+instance AttrInfo CellAreaEditWidgetPropertyInfo where+    type AttrAllowedOps CellAreaEditWidgetPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaEditWidgetPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaEditWidgetPropertyInfo = CellAreaK+    type AttrGetType CellAreaEditWidgetPropertyInfo = CellEditable+    type AttrLabel CellAreaEditWidgetPropertyInfo = "CellArea::edit-widget"+    attrGet _ = getCellAreaEditWidget+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "edited-cell"+   -- Type: TInterface "Gtk" "CellRenderer"+   -- Flags: [PropertyReadable]++getCellAreaEditedCell :: (MonadIO m, CellAreaK o) => o -> m CellRenderer+getCellAreaEditedCell obj = liftIO $ getObjectPropertyObject obj "edited-cell" CellRenderer++data CellAreaEditedCellPropertyInfo+instance AttrInfo CellAreaEditedCellPropertyInfo where+    type AttrAllowedOps CellAreaEditedCellPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaEditedCellPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaEditedCellPropertyInfo = CellAreaK+    type AttrGetType CellAreaEditedCellPropertyInfo = CellRenderer+    type AttrLabel CellAreaEditedCellPropertyInfo = "CellArea::edited-cell"+    attrGet _ = getCellAreaEditedCell+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "focus-cell"+   -- Type: TInterface "Gtk" "CellRenderer"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellAreaFocusCell :: (MonadIO m, CellAreaK o) => o -> m CellRenderer+getCellAreaFocusCell obj = liftIO $ getObjectPropertyObject obj "focus-cell" CellRenderer++setCellAreaFocusCell :: (MonadIO m, CellAreaK o, CellRendererK a) => o -> a -> m ()+setCellAreaFocusCell obj val = liftIO $ setObjectPropertyObject obj "focus-cell" val++constructCellAreaFocusCell :: (CellRendererK a) => a -> IO ([Char], GValue)+constructCellAreaFocusCell val = constructObjectPropertyObject "focus-cell" val++data CellAreaFocusCellPropertyInfo+instance AttrInfo CellAreaFocusCellPropertyInfo where+    type AttrAllowedOps CellAreaFocusCellPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellAreaFocusCellPropertyInfo = CellRendererK+    type AttrBaseTypeConstraint CellAreaFocusCellPropertyInfo = CellAreaK+    type AttrGetType CellAreaFocusCellPropertyInfo = CellRenderer+    type AttrLabel CellAreaFocusCellPropertyInfo = "CellArea::focus-cell"+    attrGet _ = getCellAreaFocusCell+    attrSet _ = setCellAreaFocusCell+    attrConstruct _ = constructCellAreaFocusCell++type instance AttributeList CellArea = CellAreaAttributeList+type CellAreaAttributeList = ('[ '("edit-widget", CellAreaEditWidgetPropertyInfo), '("edited-cell", CellAreaEditedCellPropertyInfo), '("focus-cell", CellAreaFocusCellPropertyInfo)] :: [(Symbol, *)])++data CellAreaAddEditableSignalInfo+instance SignalInfo CellAreaAddEditableSignalInfo where+    type HaskellCallbackType CellAreaAddEditableSignalInfo = CellAreaAddEditableCallback+    connectSignal _ = connectCellAreaAddEditable++data CellAreaApplyAttributesSignalInfo+instance SignalInfo CellAreaApplyAttributesSignalInfo where+    type HaskellCallbackType CellAreaApplyAttributesSignalInfo = CellAreaApplyAttributesCallback+    connectSignal _ = connectCellAreaApplyAttributes++data CellAreaFocusChangedSignalInfo+instance SignalInfo CellAreaFocusChangedSignalInfo where+    type HaskellCallbackType CellAreaFocusChangedSignalInfo = CellAreaFocusChangedCallback+    connectSignal _ = connectCellAreaFocusChanged++data CellAreaRemoveEditableSignalInfo+instance SignalInfo CellAreaRemoveEditableSignalInfo where+    type HaskellCallbackType CellAreaRemoveEditableSignalInfo = CellAreaRemoveEditableCallback+    connectSignal _ = connectCellAreaRemoveEditable++type instance SignalList CellArea = CellAreaSignalList+type CellAreaSignalList = ('[ '("add-editable", CellAreaAddEditableSignalInfo), '("apply-attributes", CellAreaApplyAttributesSignalInfo), '("focus-changed", CellAreaFocusChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("remove-editable", CellAreaRemoveEditableSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellArea::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edit_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edit_only", 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 "gtk_cell_area_activate" gtk_cell_area_activate :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    CInt ->                                 -- edit_only : TBasicType TBoolean+    IO CInt+++cellAreaActivate ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    Bool ->                                 -- edit_only+    m Bool+cellAreaActivate _obj context widget cell_area flags edit_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    let edit_only' = (fromIntegral . fromEnum) edit_only+    result <- gtk_cell_area_activate _obj' context' widget' cell_area' flags' edit_only'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr cell_area+    return result'++-- method CellArea::activate_cell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_activate_cell" gtk_cell_area_activate_cell :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    IO CInt+++cellAreaActivateCell ::+    (MonadIO m, CellAreaK a, WidgetK b, CellRendererK c) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    c ->                                    -- renderer+    Gdk.Event ->                            -- event+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    m Bool+cellAreaActivateCell _obj widget renderer event cell_area flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let renderer' = unsafeManagedPtrCastPtr renderer+    let event' = unsafeManagedPtrGetPtr event+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    result <- gtk_cell_area_activate_cell _obj' widget' renderer' event' cell_area' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr widget+    touchManagedPtr renderer+    touchManagedPtr event+    touchManagedPtr cell_area+    return result'++-- method CellArea::add+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_add" gtk_cell_area_add :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO ()+++cellAreaAdd ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m ()+cellAreaAdd _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    gtk_cell_area_add _obj' renderer'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return ()++-- method CellArea::add_focus_sibling+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_add_focus_sibling" gtk_cell_area_add_focus_sibling :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    Ptr CellRenderer ->                     -- sibling : TInterface "Gtk" "CellRenderer"+    IO ()+++cellAreaAddFocusSibling ::+    (MonadIO m, CellAreaK a, CellRendererK b, CellRendererK c) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    c ->                                    -- sibling+    m ()+cellAreaAddFocusSibling _obj renderer sibling = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let sibling' = unsafeManagedPtrCastPtr sibling+    gtk_cell_area_add_focus_sibling _obj' renderer' sibling'+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr sibling+    return ()++-- method CellArea::apply_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tree_model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_expander", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_expanded", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tree_model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_expander", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_expanded", 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 "gtk_cell_area_apply_attributes" gtk_cell_area_apply_attributes :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr TreeModel ->                        -- tree_model : TInterface "Gtk" "TreeModel"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    CInt ->                                 -- is_expander : TBasicType TBoolean+    CInt ->                                 -- is_expanded : TBasicType TBoolean+    IO ()+++cellAreaApplyAttributes ::+    (MonadIO m, CellAreaK a, TreeModelK b) =>+    a ->                                    -- _obj+    b ->                                    -- tree_model+    TreeIter ->                             -- iter+    Bool ->                                 -- is_expander+    Bool ->                                 -- is_expanded+    m ()+cellAreaApplyAttributes _obj tree_model iter is_expander is_expanded = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let tree_model' = unsafeManagedPtrCastPtr tree_model+    let iter' = unsafeManagedPtrGetPtr iter+    let is_expander' = (fromIntegral . fromEnum) is_expander+    let is_expanded' = (fromIntegral . fromEnum) is_expanded+    gtk_cell_area_apply_attributes _obj' tree_model' iter' is_expander' is_expanded'+    touchManagedPtr _obj+    touchManagedPtr tree_model+    touchManagedPtr iter+    return ()++-- method CellArea::attribute_connect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = "column", 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 "gtk_cell_area_attribute_connect" gtk_cell_area_attribute_connect :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CString ->                              -- attribute : TBasicType TUTF8+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++cellAreaAttributeConnect ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    T.Text ->                               -- attribute+    Int32 ->                                -- column+    m ()+cellAreaAttributeConnect _obj renderer attribute column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    attribute' <- textToCString attribute+    gtk_cell_area_attribute_connect _obj' renderer' attribute' column+    touchManagedPtr _obj+    touchManagedPtr renderer+    freeMem attribute'+    return ()++-- method CellArea::attribute_disconnect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 "gtk_cell_area_attribute_disconnect" gtk_cell_area_attribute_disconnect :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CString ->                              -- attribute : TBasicType TUTF8+    IO ()+++cellAreaAttributeDisconnect ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    T.Text ->                               -- attribute+    m ()+cellAreaAttributeDisconnect _obj renderer attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    attribute' <- textToCString attribute+    gtk_cell_area_attribute_disconnect _obj' renderer' attribute'+    touchManagedPtr _obj+    touchManagedPtr renderer+    freeMem attribute'+    return ()++-- method CellArea::attribute_get_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 "gtk_cell_area_attribute_get_column" gtk_cell_area_attribute_get_column :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CString ->                              -- attribute : TBasicType TUTF8+    IO Int32+++cellAreaAttributeGetColumn ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    T.Text ->                               -- attribute+    m Int32+cellAreaAttributeGetColumn _obj renderer attribute = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    attribute' <- textToCString attribute+    result <- gtk_cell_area_attribute_get_column _obj' renderer' attribute'+    touchManagedPtr _obj+    touchManagedPtr renderer+    freeMem attribute'+    return result++-- method CellArea::cell_get_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_cell_get_property" gtk_cell_area_cell_get_property :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CString ->                              -- property_name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++cellAreaCellGetProperty ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    T.Text ->                               -- property_name+    GValue ->                               -- value+    m ()+cellAreaCellGetProperty _obj renderer property_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    property_name' <- textToCString property_name+    let value' = unsafeManagedPtrGetPtr value+    gtk_cell_area_cell_get_property _obj' renderer' property_name' value'+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr value+    freeMem property_name'+    return ()++-- method CellArea::cell_set_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_cell_set_property" gtk_cell_area_cell_set_property :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CString ->                              -- property_name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++cellAreaCellSetProperty ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    T.Text ->                               -- property_name+    GValue ->                               -- value+    m ()+cellAreaCellSetProperty _obj renderer property_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    property_name' <- textToCString property_name+    let value' = unsafeManagedPtrGetPtr value+    gtk_cell_area_cell_set_property _obj' renderer' property_name' value'+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr value+    freeMem property_name'+    return ()++-- method CellArea::copy_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellAreaContext"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_copy_context" gtk_cell_area_copy_context :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    IO (Ptr CellAreaContext)+++cellAreaCopyContext ::+    (MonadIO m, CellAreaK a, CellAreaContextK b) =>+    a ->                                    -- _obj+    b ->                                    -- context+    m CellAreaContext+cellAreaCopyContext _obj context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    result <- gtk_cell_area_copy_context _obj' context'+    checkUnexpectedReturnNULL "gtk_cell_area_copy_context" result+    result' <- (wrapObject CellAreaContext) result+    touchManagedPtr _obj+    touchManagedPtr context+    return result'++-- method CellArea::create_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellAreaContext"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_create_context" gtk_cell_area_create_context :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO (Ptr CellAreaContext)+++cellAreaCreateContext ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m CellAreaContext+cellAreaCreateContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_create_context _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_create_context" result+    result' <- (wrapObject CellAreaContext) result+    touchManagedPtr _obj+    return result'++-- method CellArea::event+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_event" gtk_cell_area_event :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    IO Int32+++cellAreaEvent ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Gdk.Event ->                            -- event+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    m Int32+cellAreaEvent _obj context widget event cell_area flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let event' = unsafeManagedPtrGetPtr event+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    result <- gtk_cell_area_event _obj' context' widget' event' cell_area' flags'+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr event+    touchManagedPtr cell_area+    return result++-- method CellArea::focus+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "DirectionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "DirectionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_focus" gtk_cell_area_focus :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    CUInt ->                                -- direction : TInterface "Gtk" "DirectionType"+    IO CInt+++cellAreaFocus ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    DirectionType ->                        -- direction+    m Bool+cellAreaFocus _obj direction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let direction' = (fromIntegral . fromEnum) direction+    result <- gtk_cell_area_focus _obj' direction'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellArea::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "CellCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "CellCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_foreach" gtk_cell_area_foreach :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    FunPtr CellCallbackC ->                 -- callback : TInterface "Gtk" "CellCallback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    IO ()+++cellAreaForeach ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    CellCallback ->                         -- callback+    m ()+cellAreaForeach _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    callback' <- mkCellCallback (cellCallbackWrapper Nothing callback)+    let callback_data = nullPtr+    gtk_cell_area_foreach _obj' callback' callback_data+    safeFreeFunPtr $ castFunPtrToPtr callback'+    touchManagedPtr _obj+    return ()++-- method CellArea::foreach_alloc+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "CellAllocCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 6, 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 = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "CellAllocCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 6, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_foreach_alloc" gtk_cell_area_foreach_alloc :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"+    FunPtr CellAllocCallbackC ->            -- callback : TInterface "Gtk" "CellAllocCallback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    IO ()+++cellAreaForeachAlloc ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Gdk.Rectangle ->                        -- cell_area+    Gdk.Rectangle ->                        -- background_area+    CellAllocCallback ->                    -- callback+    m ()+cellAreaForeachAlloc _obj context widget cell_area background_area callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let background_area' = unsafeManagedPtrGetPtr background_area+    callback' <- mkCellAllocCallback (cellAllocCallbackWrapper Nothing callback)+    let callback_data = nullPtr+    gtk_cell_area_foreach_alloc _obj' context' widget' cell_area' background_area' callback' callback_data+    safeFreeFunPtr $ castFunPtrToPtr callback'+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr cell_area+    touchManagedPtr background_area+    return ()++-- method CellArea::get_cell_allocation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allocation", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_cell_allocation" gtk_cell_area_get_cell_allocation :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- allocation : TInterface "Gdk" "Rectangle"+    IO ()+++cellAreaGetCellAllocation ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c, CellRendererK d) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    d ->                                    -- renderer+    Gdk.Rectangle ->                        -- cell_area+    m (Gdk.Rectangle)+cellAreaGetCellAllocation _obj context widget renderer cell_area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let renderer' = unsafeManagedPtrCastPtr renderer+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    allocation <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_cell_area_get_cell_allocation _obj' context' widget' renderer' cell_area' allocation+    allocation' <- (wrapBoxed Gdk.Rectangle) allocation+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr renderer+    touchManagedPtr cell_area+    return allocation'++-- method CellArea::get_cell_at_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alloc_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellRenderer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_cell_at_position" gtk_cell_area_get_cell_at_position :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Ptr Gdk.Rectangle ->                    -- alloc_area : TInterface "Gdk" "Rectangle"+    IO (Ptr CellRenderer)+++cellAreaGetCellAtPosition ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Gdk.Rectangle ->                        -- cell_area+    Int32 ->                                -- x+    Int32 ->                                -- y+    m (CellRenderer,Gdk.Rectangle)+cellAreaGetCellAtPosition _obj context widget cell_area x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    alloc_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_cell_area_get_cell_at_position _obj' context' widget' cell_area' x y alloc_area+    checkUnexpectedReturnNULL "gtk_cell_area_get_cell_at_position" result+    result' <- (newObject CellRenderer) result+    alloc_area' <- (wrapBoxed Gdk.Rectangle) alloc_area+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr cell_area+    return (result', alloc_area')++-- method CellArea::get_current_path_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_current_path_string" gtk_cell_area_get_current_path_string :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO CString+++cellAreaGetCurrentPathString ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m T.Text+cellAreaGetCurrentPathString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_get_current_path_string _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_get_current_path_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method CellArea::get_edit_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellEditable"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_edit_widget" gtk_cell_area_get_edit_widget :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO (Ptr CellEditable)+++cellAreaGetEditWidget ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m CellEditable+cellAreaGetEditWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_get_edit_widget _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_get_edit_widget" result+    result' <- (newObject CellEditable) result+    touchManagedPtr _obj+    return result'++-- method CellArea::get_edited_cell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellRenderer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_edited_cell" gtk_cell_area_get_edited_cell :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO (Ptr CellRenderer)+++cellAreaGetEditedCell ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m CellRenderer+cellAreaGetEditedCell _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_get_edited_cell _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_get_edited_cell" result+    result' <- (newObject CellRenderer) result+    touchManagedPtr _obj+    return result'++-- method CellArea::get_focus_cell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellRenderer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_focus_cell" gtk_cell_area_get_focus_cell :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO (Ptr CellRenderer)+++cellAreaGetFocusCell ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m CellRenderer+cellAreaGetFocusCell _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_get_focus_cell _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_get_focus_cell" result+    result' <- (newObject CellRenderer) result+    touchManagedPtr _obj+    return result'++-- method CellArea::get_focus_from_sibling+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellRenderer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_focus_from_sibling" gtk_cell_area_get_focus_from_sibling :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO (Ptr CellRenderer)+++cellAreaGetFocusFromSibling ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m CellRenderer+cellAreaGetFocusFromSibling _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    result <- gtk_cell_area_get_focus_from_sibling _obj' renderer'+    checkUnexpectedReturnNULL "gtk_cell_area_get_focus_from_sibling" result+    result' <- (newObject CellRenderer) result+    touchManagedPtr _obj+    touchManagedPtr renderer+    return result'++-- method CellArea::get_focus_siblings+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "CellRenderer")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_focus_siblings" gtk_cell_area_get_focus_siblings :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO (Ptr (GList (Ptr CellRenderer)))+++cellAreaGetFocusSiblings ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m [CellRenderer]+cellAreaGetFocusSiblings _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    result <- gtk_cell_area_get_focus_siblings _obj' renderer'+    checkUnexpectedReturnNULL "gtk_cell_area_get_focus_siblings" result+    result' <- unpackGList result+    result'' <- mapM (newObject CellRenderer) result'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return result''++-- method CellArea::get_preferred_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_preferred_height" gtk_cell_area_get_preferred_height :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32+    Ptr Int32 ->                            -- natural_height : TBasicType TInt32+    IO ()+++cellAreaGetPreferredHeight ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    m (Int32,Int32)+cellAreaGetPreferredHeight _obj context widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_height <- allocMem :: IO (Ptr Int32)+    natural_height <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_get_preferred_height _obj' context' widget' minimum_height natural_height+    minimum_height' <- peek minimum_height+    natural_height' <- peek natural_height+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    freeMem minimum_height+    freeMem natural_height+    return (minimum_height', natural_height')++-- method CellArea::get_preferred_height_for_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", 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 "gtk_cell_area_get_preferred_height_for_width" gtk_cell_area_get_preferred_height_for_width :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- width : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32+    Ptr Int32 ->                            -- natural_height : TBasicType TInt32+    IO ()+++cellAreaGetPreferredHeightForWidth ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Int32 ->                                -- width+    m (Int32,Int32)+cellAreaGetPreferredHeightForWidth _obj context widget width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_height <- allocMem :: IO (Ptr Int32)+    natural_height <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_get_preferred_height_for_width _obj' context' widget' width minimum_height natural_height+    minimum_height' <- peek minimum_height+    natural_height' <- peek natural_height+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    freeMem minimum_height+    freeMem natural_height+    return (minimum_height', natural_height')++-- method CellArea::get_preferred_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_preferred_width" gtk_cell_area_get_preferred_width :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32+    Ptr Int32 ->                            -- natural_width : TBasicType TInt32+    IO ()+++cellAreaGetPreferredWidth ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    m (Int32,Int32)+cellAreaGetPreferredWidth _obj context widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_width <- allocMem :: IO (Ptr Int32)+    natural_width <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_get_preferred_width _obj' context' widget' minimum_width natural_width+    minimum_width' <- peek minimum_width+    natural_width' <- peek natural_width+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    freeMem minimum_width+    freeMem natural_width+    return (minimum_width', natural_width')++-- method CellArea::get_preferred_width_for_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_cell_area_get_preferred_width_for_height" gtk_cell_area_get_preferred_width_for_height :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- height : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32+    Ptr Int32 ->                            -- natural_width : TBasicType TInt32+    IO ()+++cellAreaGetPreferredWidthForHeight ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Int32 ->                                -- height+    m (Int32,Int32)+cellAreaGetPreferredWidthForHeight _obj context widget height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_width <- allocMem :: IO (Ptr Int32)+    natural_width <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_get_preferred_width_for_height _obj' context' widget' height minimum_width natural_width+    minimum_width' <- peek minimum_width+    natural_width' <- peek natural_width+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    freeMem minimum_width+    freeMem natural_width+    return (minimum_width', natural_width')++-- method CellArea::get_request_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SizeRequestMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_get_request_mode" gtk_cell_area_get_request_mode :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO CUInt+++cellAreaGetRequestMode ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m SizeRequestMode+cellAreaGetRequestMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_get_request_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method CellArea::has_renderer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_has_renderer" gtk_cell_area_has_renderer :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO CInt+++cellAreaHasRenderer ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m Bool+cellAreaHasRenderer _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    result <- gtk_cell_area_has_renderer _obj' renderer'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr renderer+    return result'++-- method CellArea::inner_cell_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inner_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_inner_cell_area" gtk_cell_area_inner_cell_area :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- inner_area : TInterface "Gdk" "Rectangle"+    IO ()+++cellAreaInnerCellArea ::+    (MonadIO m, CellAreaK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Gdk.Rectangle ->                        -- cell_area+    m (Gdk.Rectangle)+cellAreaInnerCellArea _obj widget cell_area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    inner_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_cell_area_inner_cell_area _obj' widget' cell_area' inner_area+    inner_area' <- (wrapBoxed Gdk.Rectangle) inner_area+    touchManagedPtr _obj+    touchManagedPtr widget+    touchManagedPtr cell_area+    return inner_area'++-- method CellArea::is_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_is_activatable" gtk_cell_area_is_activatable :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    IO CInt+++cellAreaIsActivatable ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    m Bool+cellAreaIsActivatable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_is_activatable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellArea::is_focus_sibling+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_is_focus_sibling" gtk_cell_area_is_focus_sibling :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    Ptr CellRenderer ->                     -- sibling : TInterface "Gtk" "CellRenderer"+    IO CInt+++cellAreaIsFocusSibling ::+    (MonadIO m, CellAreaK a, CellRendererK b, CellRendererK c) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    c ->                                    -- sibling+    m Bool+cellAreaIsFocusSibling _obj renderer sibling = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let sibling' = unsafeManagedPtrCastPtr sibling+    result <- gtk_cell_area_is_focus_sibling _obj' renderer' sibling'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr sibling+    return result'++-- method CellArea::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_remove" gtk_cell_area_remove :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO ()+++cellAreaRemove ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m ()+cellAreaRemove _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    gtk_cell_area_remove _obj' renderer'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return ()++-- method CellArea::remove_focus_sibling+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_remove_focus_sibling" gtk_cell_area_remove_focus_sibling :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    Ptr CellRenderer ->                     -- sibling : TInterface "Gtk" "CellRenderer"+    IO ()+++cellAreaRemoveFocusSibling ::+    (MonadIO m, CellAreaK a, CellRendererK b, CellRendererK c) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    c ->                                    -- sibling+    m ()+cellAreaRemoveFocusSibling _obj renderer sibling = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let sibling' = unsafeManagedPtrCastPtr sibling+    gtk_cell_area_remove_focus_sibling _obj' renderer' sibling'+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr sibling+    return ()++-- method CellArea::render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paint_focus", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paint_focus", 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 "gtk_cell_area_render" gtk_cell_area_render :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    CInt ->                                 -- paint_focus : TBasicType TBoolean+    IO ()+++cellAreaRender ::+    (MonadIO m, CellAreaK a, CellAreaContextK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    c ->                                    -- widget+    Cairo.Context ->                        -- cr+    Gdk.Rectangle ->                        -- background_area+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    Bool ->                                 -- paint_focus+    m ()+cellAreaRender _obj context widget cr background_area cell_area flags paint_focus = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    let widget' = unsafeManagedPtrCastPtr widget+    let cr' = unsafeManagedPtrGetPtr cr+    let background_area' = unsafeManagedPtrGetPtr background_area+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    let paint_focus' = (fromIntegral . fromEnum) paint_focus+    gtk_cell_area_render _obj' context' widget' cr' background_area' cell_area' flags' paint_focus'+    touchManagedPtr _obj+    touchManagedPtr context+    touchManagedPtr widget+    touchManagedPtr cr+    touchManagedPtr background_area+    touchManagedPtr cell_area+    return ()++-- method CellArea::request_renderer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_size", 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 "gtk_cell_area_request_renderer" gtk_cell_area_request_renderer :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- for_size : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_size : TBasicType TInt32+    Ptr Int32 ->                            -- natural_size : TBasicType TInt32+    IO ()+++cellAreaRequestRenderer ::+    (MonadIO m, CellAreaK a, CellRendererK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    Orientation ->                          -- orientation+    c ->                                    -- widget+    Int32 ->                                -- for_size+    m (Int32,Int32)+cellAreaRequestRenderer _obj renderer orientation widget for_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let orientation' = (fromIntegral . fromEnum) orientation+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_size <- allocMem :: IO (Ptr Int32)+    natural_size <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_request_renderer _obj' renderer' orientation' widget' for_size minimum_size natural_size+    minimum_size' <- peek minimum_size+    natural_size' <- peek natural_size+    touchManagedPtr _obj+    touchManagedPtr renderer+    touchManagedPtr widget+    freeMem minimum_size+    freeMem natural_size+    return (minimum_size', natural_size')++-- method CellArea::set_focus_cell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_set_focus_cell" gtk_cell_area_set_focus_cell :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    IO ()+++cellAreaSetFocusCell ::+    (MonadIO m, CellAreaK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    m ()+cellAreaSetFocusCell _obj renderer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    gtk_cell_area_set_focus_cell _obj' renderer'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return ()++-- method CellArea::stop_editing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", 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 "gtk_cell_area_stop_editing" gtk_cell_area_stop_editing :: +    Ptr CellArea ->                         -- _obj : TInterface "Gtk" "CellArea"+    CInt ->                                 -- canceled : TBasicType TBoolean+    IO ()+++cellAreaStopEditing ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- canceled+    m ()+cellAreaStopEditing _obj canceled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let canceled' = (fromIntegral . fromEnum) canceled+    gtk_cell_area_stop_editing _obj' canceled'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellArea.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gtk.Objects.CellArea where++import Prelude ()+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 CellArea = CellArea (ForeignPtr CellArea)+instance GObject CellArea where+class GObject o => CellAreaK o+instance (GObject o, IsDescendantOf CellArea o) => CellAreaK o+data CellAreaEditWidgetPropertyInfo+data CellAreaEditedCellPropertyInfo+data CellAreaFocusCellPropertyInfo+data CellAreaAddEditableSignalInfo+data CellAreaApplyAttributesSignalInfo+data CellAreaFocusChangedSignalInfo+data CellAreaRemoveEditableSignalInfo
+ GI/Gtk/Objects/CellAreaBox.hs view
@@ -0,0 +1,261 @@++{- |+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.Gtk.Objects.CellAreaBox+    ( ++-- * Exported types+    CellAreaBox(..)                         ,+    CellAreaBoxK                            ,+    toCellAreaBox                           ,+    noCellAreaBox                           ,+++ -- * Methods+-- ** cellAreaBoxGetSpacing+    cellAreaBoxGetSpacing                   ,+++-- ** cellAreaBoxNew+    cellAreaBoxNew                          ,+++-- ** cellAreaBoxPackEnd+    cellAreaBoxPackEnd                      ,+++-- ** cellAreaBoxPackStart+    cellAreaBoxPackStart                    ,+++-- ** cellAreaBoxSetSpacing+    cellAreaBoxSetSpacing                   ,+++++ -- * Properties+-- ** Spacing+    CellAreaBoxSpacingPropertyInfo          ,+    constructCellAreaBoxSpacing             ,+    getCellAreaBoxSpacing                   ,+    setCellAreaBoxSpacing                   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellAreaBox = CellAreaBox (ForeignPtr CellAreaBox)+foreign import ccall "gtk_cell_area_box_get_type"+    c_gtk_cell_area_box_get_type :: IO GType++type instance ParentTypes CellAreaBox = CellAreaBoxParentTypes+type CellAreaBoxParentTypes = '[CellArea, GObject.Object, Buildable, CellLayout, Orientable]++instance GObject CellAreaBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_area_box_get_type+    ++class GObject o => CellAreaBoxK o+instance (GObject o, IsDescendantOf CellAreaBox o) => CellAreaBoxK o++toCellAreaBox :: CellAreaBoxK o => o -> IO CellAreaBox+toCellAreaBox = unsafeCastTo CellAreaBox++noCellAreaBox :: Maybe CellAreaBox+noCellAreaBox = Nothing++-- VVV Prop "spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellAreaBoxSpacing :: (MonadIO m, CellAreaBoxK o) => o -> m Int32+getCellAreaBoxSpacing obj = liftIO $ getObjectPropertyCInt obj "spacing"++setCellAreaBoxSpacing :: (MonadIO m, CellAreaBoxK o) => o -> Int32 -> m ()+setCellAreaBoxSpacing obj val = liftIO $ setObjectPropertyCInt obj "spacing" val++constructCellAreaBoxSpacing :: Int32 -> IO ([Char], GValue)+constructCellAreaBoxSpacing val = constructObjectPropertyCInt "spacing" val++data CellAreaBoxSpacingPropertyInfo+instance AttrInfo CellAreaBoxSpacingPropertyInfo where+    type AttrAllowedOps CellAreaBoxSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellAreaBoxSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellAreaBoxSpacingPropertyInfo = CellAreaBoxK+    type AttrGetType CellAreaBoxSpacingPropertyInfo = Int32+    type AttrLabel CellAreaBoxSpacingPropertyInfo = "CellAreaBox::spacing"+    attrGet _ = getCellAreaBoxSpacing+    attrSet _ = setCellAreaBoxSpacing+    attrConstruct _ = constructCellAreaBoxSpacing++type instance AttributeList CellAreaBox = CellAreaBoxAttributeList+type CellAreaBoxAttributeList = ('[ '("edit-widget", CellAreaEditWidgetPropertyInfo), '("edited-cell", CellAreaEditedCellPropertyInfo), '("focus-cell", CellAreaFocusCellPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("spacing", CellAreaBoxSpacingPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellAreaBox = CellAreaBoxSignalList+type CellAreaBoxSignalList = ('[ '("add-editable", CellAreaAddEditableSignalInfo), '("apply-attributes", CellAreaApplyAttributesSignalInfo), '("focus-changed", CellAreaFocusChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("remove-editable", CellAreaRemoveEditableSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellAreaBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellAreaBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_box_new" gtk_cell_area_box_new :: +    IO (Ptr CellAreaBox)+++cellAreaBoxNew ::+    (MonadIO m) =>+    m CellAreaBox+cellAreaBoxNew  = liftIO $ do+    result <- gtk_cell_area_box_new+    checkUnexpectedReturnNULL "gtk_cell_area_box_new" result+    result' <- (newObject CellAreaBox) result+    return result'++-- method CellAreaBox::get_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_box_get_spacing" gtk_cell_area_box_get_spacing :: +    Ptr CellAreaBox ->                      -- _obj : TInterface "Gtk" "CellAreaBox"+    IO Int32+++cellAreaBoxGetSpacing ::+    (MonadIO m, CellAreaBoxK a) =>+    a ->                                    -- _obj+    m Int32+cellAreaBoxGetSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_box_get_spacing _obj'+    touchManagedPtr _obj+    return result++-- method CellAreaBox::pack_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", 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 "gtk_cell_area_box_pack_end" gtk_cell_area_box_pack_end :: +    Ptr CellAreaBox ->                      -- _obj : TInterface "Gtk" "CellAreaBox"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- expand : TBasicType TBoolean+    CInt ->                                 -- align : TBasicType TBoolean+    CInt ->                                 -- fixed : TBasicType TBoolean+    IO ()+++cellAreaBoxPackEnd ::+    (MonadIO m, CellAreaBoxK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    Bool ->                                 -- expand+    Bool ->                                 -- align+    Bool ->                                 -- fixed+    m ()+cellAreaBoxPackEnd _obj renderer expand align fixed = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let expand' = (fromIntegral . fromEnum) expand+    let align' = (fromIntegral . fromEnum) align+    let fixed' = (fromIntegral . fromEnum) fixed+    gtk_cell_area_box_pack_end _obj' renderer' expand' align' fixed'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return ()++-- method CellAreaBox::pack_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "renderer", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", 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 "gtk_cell_area_box_pack_start" gtk_cell_area_box_pack_start :: +    Ptr CellAreaBox ->                      -- _obj : TInterface "Gtk" "CellAreaBox"+    Ptr CellRenderer ->                     -- renderer : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- expand : TBasicType TBoolean+    CInt ->                                 -- align : TBasicType TBoolean+    CInt ->                                 -- fixed : TBasicType TBoolean+    IO ()+++cellAreaBoxPackStart ::+    (MonadIO m, CellAreaBoxK a, CellRendererK b) =>+    a ->                                    -- _obj+    b ->                                    -- renderer+    Bool ->                                 -- expand+    Bool ->                                 -- align+    Bool ->                                 -- fixed+    m ()+cellAreaBoxPackStart _obj renderer expand align fixed = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let renderer' = unsafeManagedPtrCastPtr renderer+    let expand' = (fromIntegral . fromEnum) expand+    let align' = (fromIntegral . fromEnum) align+    let fixed' = (fromIntegral . fromEnum) fixed+    gtk_cell_area_box_pack_start _obj' renderer' expand' align' fixed'+    touchManagedPtr _obj+    touchManagedPtr renderer+    return ()++-- method CellAreaBox::set_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_cell_area_box_set_spacing" gtk_cell_area_box_set_spacing :: +    Ptr CellAreaBox ->                      -- _obj : TInterface "Gtk" "CellAreaBox"+    Int32 ->                                -- spacing : TBasicType TInt32+    IO ()+++cellAreaBoxSetSpacing ::+    (MonadIO m, CellAreaBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- spacing+    m ()+cellAreaBoxSetSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_area_box_set_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellAreaBox.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.CellAreaBox where++import Prelude ()+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 CellAreaBox = CellAreaBox (ForeignPtr CellAreaBox)+instance GObject CellAreaBox where+class GObject o => CellAreaBoxK o+instance (GObject o, IsDescendantOf CellAreaBox o) => CellAreaBoxK o+data CellAreaBoxSpacingPropertyInfo
+ GI/Gtk/Objects/CellAreaContext.hs view
@@ -0,0 +1,521 @@++{- |+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.Gtk.Objects.CellAreaContext+    ( ++-- * Exported types+    CellAreaContext(..)                     ,+    CellAreaContextK                        ,+    toCellAreaContext                       ,+    noCellAreaContext                       ,+++ -- * Methods+-- ** cellAreaContextAllocate+    cellAreaContextAllocate                 ,+++-- ** cellAreaContextGetAllocation+    cellAreaContextGetAllocation            ,+++-- ** cellAreaContextGetArea+    cellAreaContextGetArea                  ,+++-- ** cellAreaContextGetPreferredHeight+    cellAreaContextGetPreferredHeight       ,+++-- ** cellAreaContextGetPreferredHeightForWidth+    cellAreaContextGetPreferredHeightForWidth,+++-- ** cellAreaContextGetPreferredWidth+    cellAreaContextGetPreferredWidth        ,+++-- ** cellAreaContextGetPreferredWidthForHeight+    cellAreaContextGetPreferredWidthForHeight,+++-- ** cellAreaContextPushPreferredHeight+    cellAreaContextPushPreferredHeight      ,+++-- ** cellAreaContextPushPreferredWidth+    cellAreaContextPushPreferredWidth       ,+++-- ** cellAreaContextReset+    cellAreaContextReset                    ,+++++ -- * Properties+-- ** Area+    CellAreaContextAreaPropertyInfo         ,+    constructCellAreaContextArea            ,+    getCellAreaContextArea                  ,+++-- ** MinimumHeight+    CellAreaContextMinimumHeightPropertyInfo,+    getCellAreaContextMinimumHeight         ,+++-- ** MinimumWidth+    CellAreaContextMinimumWidthPropertyInfo ,+    getCellAreaContextMinimumWidth          ,+++-- ** NaturalHeight+    CellAreaContextNaturalHeightPropertyInfo,+    getCellAreaContextNaturalHeight         ,+++-- ** NaturalWidth+    CellAreaContextNaturalWidthPropertyInfo ,+    getCellAreaContextNaturalWidth          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellAreaContext = CellAreaContext (ForeignPtr CellAreaContext)+foreign import ccall "gtk_cell_area_context_get_type"+    c_gtk_cell_area_context_get_type :: IO GType++type instance ParentTypes CellAreaContext = CellAreaContextParentTypes+type CellAreaContextParentTypes = '[GObject.Object]++instance GObject CellAreaContext where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_cell_area_context_get_type+    ++class GObject o => CellAreaContextK o+instance (GObject o, IsDescendantOf CellAreaContext o) => CellAreaContextK o++toCellAreaContext :: CellAreaContextK o => o -> IO CellAreaContext+toCellAreaContext = unsafeCastTo CellAreaContext++noCellAreaContext :: Maybe CellAreaContext+noCellAreaContext = Nothing++-- VVV Prop "area"+   -- Type: TInterface "Gtk" "CellArea"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getCellAreaContextArea :: (MonadIO m, CellAreaContextK o) => o -> m CellArea+getCellAreaContextArea obj = liftIO $ getObjectPropertyObject obj "area" CellArea++constructCellAreaContextArea :: (CellAreaK a) => a -> IO ([Char], GValue)+constructCellAreaContextArea val = constructObjectPropertyObject "area" val++data CellAreaContextAreaPropertyInfo+instance AttrInfo CellAreaContextAreaPropertyInfo where+    type AttrAllowedOps CellAreaContextAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellAreaContextAreaPropertyInfo = CellAreaK+    type AttrBaseTypeConstraint CellAreaContextAreaPropertyInfo = CellAreaContextK+    type AttrGetType CellAreaContextAreaPropertyInfo = CellArea+    type AttrLabel CellAreaContextAreaPropertyInfo = "CellAreaContext::area"+    attrGet _ = getCellAreaContextArea+    attrSet _ = undefined+    attrConstruct _ = constructCellAreaContextArea++-- VVV Prop "minimum-height"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getCellAreaContextMinimumHeight :: (MonadIO m, CellAreaContextK o) => o -> m Int32+getCellAreaContextMinimumHeight obj = liftIO $ getObjectPropertyCInt obj "minimum-height"++data CellAreaContextMinimumHeightPropertyInfo+instance AttrInfo CellAreaContextMinimumHeightPropertyInfo where+    type AttrAllowedOps CellAreaContextMinimumHeightPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaContextMinimumHeightPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaContextMinimumHeightPropertyInfo = CellAreaContextK+    type AttrGetType CellAreaContextMinimumHeightPropertyInfo = Int32+    type AttrLabel CellAreaContextMinimumHeightPropertyInfo = "CellAreaContext::minimum-height"+    attrGet _ = getCellAreaContextMinimumHeight+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "minimum-width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getCellAreaContextMinimumWidth :: (MonadIO m, CellAreaContextK o) => o -> m Int32+getCellAreaContextMinimumWidth obj = liftIO $ getObjectPropertyCInt obj "minimum-width"++data CellAreaContextMinimumWidthPropertyInfo+instance AttrInfo CellAreaContextMinimumWidthPropertyInfo where+    type AttrAllowedOps CellAreaContextMinimumWidthPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaContextMinimumWidthPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaContextMinimumWidthPropertyInfo = CellAreaContextK+    type AttrGetType CellAreaContextMinimumWidthPropertyInfo = Int32+    type AttrLabel CellAreaContextMinimumWidthPropertyInfo = "CellAreaContext::minimum-width"+    attrGet _ = getCellAreaContextMinimumWidth+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "natural-height"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getCellAreaContextNaturalHeight :: (MonadIO m, CellAreaContextK o) => o -> m Int32+getCellAreaContextNaturalHeight obj = liftIO $ getObjectPropertyCInt obj "natural-height"++data CellAreaContextNaturalHeightPropertyInfo+instance AttrInfo CellAreaContextNaturalHeightPropertyInfo where+    type AttrAllowedOps CellAreaContextNaturalHeightPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaContextNaturalHeightPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaContextNaturalHeightPropertyInfo = CellAreaContextK+    type AttrGetType CellAreaContextNaturalHeightPropertyInfo = Int32+    type AttrLabel CellAreaContextNaturalHeightPropertyInfo = "CellAreaContext::natural-height"+    attrGet _ = getCellAreaContextNaturalHeight+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "natural-width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getCellAreaContextNaturalWidth :: (MonadIO m, CellAreaContextK o) => o -> m Int32+getCellAreaContextNaturalWidth obj = liftIO $ getObjectPropertyCInt obj "natural-width"++data CellAreaContextNaturalWidthPropertyInfo+instance AttrInfo CellAreaContextNaturalWidthPropertyInfo where+    type AttrAllowedOps CellAreaContextNaturalWidthPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellAreaContextNaturalWidthPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellAreaContextNaturalWidthPropertyInfo = CellAreaContextK+    type AttrGetType CellAreaContextNaturalWidthPropertyInfo = Int32+    type AttrLabel CellAreaContextNaturalWidthPropertyInfo = "CellAreaContext::natural-width"+    attrGet _ = getCellAreaContextNaturalWidth+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList CellAreaContext = CellAreaContextAttributeList+type CellAreaContextAttributeList = ('[ '("area", CellAreaContextAreaPropertyInfo), '("minimum-height", CellAreaContextMinimumHeightPropertyInfo), '("minimum-width", CellAreaContextMinimumWidthPropertyInfo), '("natural-height", CellAreaContextNaturalHeightPropertyInfo), '("natural-width", CellAreaContextNaturalWidthPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellAreaContext = CellAreaContextSignalList+type CellAreaContextSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellAreaContext::allocate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_cell_area_context_allocate" gtk_cell_area_context_allocate :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()+++cellAreaContextAllocate ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+cellAreaContextAllocate _obj width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_area_context_allocate _obj' width height+    touchManagedPtr _obj+    return ()++-- method CellAreaContext::get_allocation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_context_get_allocation" gtk_cell_area_context_get_allocation :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO ()+++cellAreaContextGetAllocation ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+cellAreaContextGetAllocation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_context_get_allocation _obj' width height+    width' <- peek width+    height' <- peek height+    touchManagedPtr _obj+    freeMem width+    freeMem height+    return (width', height')++-- method CellAreaContext::get_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellArea"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_context_get_area" gtk_cell_area_context_get_area :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    IO (Ptr CellArea)+++cellAreaContextGetArea ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    m CellArea+cellAreaContextGetArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_area_context_get_area _obj'+    checkUnexpectedReturnNULL "gtk_cell_area_context_get_area" result+    result' <- (newObject CellArea) result+    touchManagedPtr _obj+    return result'++-- method CellAreaContext::get_preferred_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_context_get_preferred_height" gtk_cell_area_context_get_preferred_height :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32+    Ptr Int32 ->                            -- natural_height : TBasicType TInt32+    IO ()+++cellAreaContextGetPreferredHeight ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+cellAreaContextGetPreferredHeight _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minimum_height <- allocMem :: IO (Ptr Int32)+    natural_height <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_context_get_preferred_height _obj' minimum_height natural_height+    minimum_height' <- peek minimum_height+    natural_height' <- peek natural_height+    touchManagedPtr _obj+    freeMem minimum_height+    freeMem natural_height+    return (minimum_height', natural_height')++-- method CellAreaContext::get_preferred_height_for_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", 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 "gtk_cell_area_context_get_preferred_height_for_width" gtk_cell_area_context_get_preferred_height_for_width :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Int32 ->                                -- width : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32+    Ptr Int32 ->                            -- natural_height : TBasicType TInt32+    IO ()+++cellAreaContextGetPreferredHeightForWidth ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- width+    m (Int32,Int32)+cellAreaContextGetPreferredHeightForWidth _obj width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minimum_height <- allocMem :: IO (Ptr Int32)+    natural_height <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_context_get_preferred_height_for_width _obj' width minimum_height natural_height+    minimum_height' <- peek minimum_height+    natural_height' <- peek natural_height+    touchManagedPtr _obj+    freeMem minimum_height+    freeMem natural_height+    return (minimum_height', natural_height')++-- method CellAreaContext::get_preferred_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_context_get_preferred_width" gtk_cell_area_context_get_preferred_width :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32+    Ptr Int32 ->                            -- natural_width : TBasicType TInt32+    IO ()+++cellAreaContextGetPreferredWidth ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+cellAreaContextGetPreferredWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minimum_width <- allocMem :: IO (Ptr Int32)+    natural_width <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_context_get_preferred_width _obj' minimum_width natural_width+    minimum_width' <- peek minimum_width+    natural_width' <- peek natural_width+    touchManagedPtr _obj+    freeMem minimum_width+    freeMem natural_width+    return (minimum_width', natural_width')++-- method CellAreaContext::get_preferred_width_for_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_cell_area_context_get_preferred_width_for_height" gtk_cell_area_context_get_preferred_width_for_height :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Int32 ->                                -- height : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32+    Ptr Int32 ->                            -- natural_width : TBasicType TInt32+    IO ()+++cellAreaContextGetPreferredWidthForHeight ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- height+    m (Int32,Int32)+cellAreaContextGetPreferredWidthForHeight _obj height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    minimum_width <- allocMem :: IO (Ptr Int32)+    natural_width <- allocMem :: IO (Ptr Int32)+    gtk_cell_area_context_get_preferred_width_for_height _obj' height minimum_width natural_width+    minimum_width' <- peek minimum_width+    natural_width' <- peek natural_width+    touchManagedPtr _obj+    freeMem minimum_width+    freeMem natural_width+    return (minimum_width', natural_width')++-- method CellAreaContext::push_preferred_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_height", 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 "gtk_cell_area_context_push_preferred_height" gtk_cell_area_context_push_preferred_height :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Int32 ->                                -- minimum_height : TBasicType TInt32+    Int32 ->                                -- natural_height : TBasicType TInt32+    IO ()+++cellAreaContextPushPreferredHeight ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- minimum_height+    Int32 ->                                -- natural_height+    m ()+cellAreaContextPushPreferredHeight _obj minimum_height natural_height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_area_context_push_preferred_height _obj' minimum_height natural_height+    touchManagedPtr _obj+    return ()++-- method CellAreaContext::push_preferred_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_width", 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 "gtk_cell_area_context_push_preferred_width" gtk_cell_area_context_push_preferred_width :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    Int32 ->                                -- minimum_width : TBasicType TInt32+    Int32 ->                                -- natural_width : TBasicType TInt32+    IO ()+++cellAreaContextPushPreferredWidth ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- minimum_width+    Int32 ->                                -- natural_width+    m ()+cellAreaContextPushPreferredWidth _obj minimum_width natural_width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_area_context_push_preferred_width _obj' minimum_width natural_width+    touchManagedPtr _obj+    return ()++-- method CellAreaContext::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_area_context_reset" gtk_cell_area_context_reset :: +    Ptr CellAreaContext ->                  -- _obj : TInterface "Gtk" "CellAreaContext"+    IO ()+++cellAreaContextReset ::+    (MonadIO m, CellAreaContextK a) =>+    a ->                                    -- _obj+    m ()+cellAreaContextReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_area_context_reset _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellAreaContext.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.CellAreaContext where++import Prelude ()+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 CellAreaContext = CellAreaContext (ForeignPtr CellAreaContext)+instance GObject CellAreaContext where+class GObject o => CellAreaContextK o+instance (GObject o, IsDescendantOf CellAreaContext o) => CellAreaContextK o+data CellAreaContextAreaPropertyInfo+data CellAreaContextMinimumHeightPropertyInfo+data CellAreaContextMinimumWidthPropertyInfo+data CellAreaContextNaturalHeightPropertyInfo+data CellAreaContextNaturalWidthPropertyInfo
+ GI/Gtk/Objects/CellRenderer.hs view
@@ -0,0 +1,1576 @@++{- |+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.Gtk.Objects.CellRenderer+    ( ++-- * Exported types+    CellRenderer(..)                        ,+    CellRendererK                           ,+    toCellRenderer                          ,+    noCellRenderer                          ,+++ -- * Methods+-- ** cellRendererActivate+    cellRendererActivate                    ,+++-- ** cellRendererGetAlignedArea+    cellRendererGetAlignedArea              ,+++-- ** cellRendererGetAlignment+    cellRendererGetAlignment                ,+++-- ** cellRendererGetFixedSize+    cellRendererGetFixedSize                ,+++-- ** cellRendererGetPadding+    cellRendererGetPadding                  ,+++-- ** cellRendererGetPreferredHeight+    cellRendererGetPreferredHeight          ,+++-- ** cellRendererGetPreferredHeightForWidth+    cellRendererGetPreferredHeightForWidth  ,+++-- ** cellRendererGetPreferredSize+    cellRendererGetPreferredSize            ,+++-- ** cellRendererGetPreferredWidth+    cellRendererGetPreferredWidth           ,+++-- ** cellRendererGetPreferredWidthForHeight+    cellRendererGetPreferredWidthForHeight  ,+++-- ** cellRendererGetRequestMode+    cellRendererGetRequestMode              ,+++-- ** cellRendererGetSensitive+    cellRendererGetSensitive                ,+++-- ** cellRendererGetSize+    cellRendererGetSize                     ,+++-- ** cellRendererGetState+    cellRendererGetState                    ,+++-- ** cellRendererGetVisible+    cellRendererGetVisible                  ,+++-- ** cellRendererIsActivatable+    cellRendererIsActivatable               ,+++-- ** cellRendererRender+    cellRendererRender                      ,+++-- ** cellRendererSetAlignment+    cellRendererSetAlignment                ,+++-- ** cellRendererSetFixedSize+    cellRendererSetFixedSize                ,+++-- ** cellRendererSetPadding+    cellRendererSetPadding                  ,+++-- ** cellRendererSetSensitive+    cellRendererSetSensitive                ,+++-- ** cellRendererSetVisible+    cellRendererSetVisible                  ,+++-- ** cellRendererStartEditing+    cellRendererStartEditing                ,+++-- ** cellRendererStopEditing+    cellRendererStopEditing                 ,+++++ -- * Properties+-- ** CellBackground+    CellRendererCellBackgroundPropertyInfo  ,+    constructCellRendererCellBackground     ,+    setCellRendererCellBackground           ,+++-- ** CellBackgroundGdk+    CellRendererCellBackgroundGdkPropertyInfo,+    constructCellRendererCellBackgroundGdk  ,+    getCellRendererCellBackgroundGdk        ,+    setCellRendererCellBackgroundGdk        ,+++-- ** CellBackgroundRgba+    CellRendererCellBackgroundRgbaPropertyInfo,+    constructCellRendererCellBackgroundRgba ,+    getCellRendererCellBackgroundRgba       ,+    setCellRendererCellBackgroundRgba       ,+++-- ** CellBackgroundSet+    CellRendererCellBackgroundSetPropertyInfo,+    constructCellRendererCellBackgroundSet  ,+    getCellRendererCellBackgroundSet        ,+    setCellRendererCellBackgroundSet        ,+++-- ** Editing+    CellRendererEditingPropertyInfo         ,+    getCellRendererEditing                  ,+++-- ** Height+    CellRendererHeightPropertyInfo          ,+    constructCellRendererHeight             ,+    getCellRendererHeight                   ,+    setCellRendererHeight                   ,+++-- ** IsExpanded+    CellRendererIsExpandedPropertyInfo      ,+    constructCellRendererIsExpanded         ,+    getCellRendererIsExpanded               ,+    setCellRendererIsExpanded               ,+++-- ** IsExpander+    CellRendererIsExpanderPropertyInfo      ,+    constructCellRendererIsExpander         ,+    getCellRendererIsExpander               ,+    setCellRendererIsExpander               ,+++-- ** Mode+    CellRendererModePropertyInfo            ,+    constructCellRendererMode               ,+    getCellRendererMode                     ,+    setCellRendererMode                     ,+++-- ** Sensitive+    CellRendererSensitivePropertyInfo       ,+    constructCellRendererSensitive          ,+    getCellRendererSensitive                ,+    setCellRendererSensitive                ,+++-- ** Visible+    CellRendererVisiblePropertyInfo         ,+    constructCellRendererVisible            ,+    getCellRendererVisible                  ,+    setCellRendererVisible                  ,+++-- ** Width+    CellRendererWidthPropertyInfo           ,+    constructCellRendererWidth              ,+    getCellRendererWidth                    ,+    setCellRendererWidth                    ,+++-- ** Xalign+    CellRendererXalignPropertyInfo          ,+    constructCellRendererXalign             ,+    getCellRendererXalign                   ,+    setCellRendererXalign                   ,+++-- ** Xpad+    CellRendererXpadPropertyInfo            ,+    constructCellRendererXpad               ,+    getCellRendererXpad                     ,+    setCellRendererXpad                     ,+++-- ** Yalign+    CellRendererYalignPropertyInfo          ,+    constructCellRendererYalign             ,+    getCellRendererYalign                   ,+    setCellRendererYalign                   ,+++-- ** Ypad+    CellRendererYpadPropertyInfo            ,+    constructCellRendererYpad               ,+    getCellRendererYpad                     ,+    setCellRendererYpad                     ,+++++ -- * Signals+-- ** EditingCanceled+    CellRendererEditingCanceledCallback     ,+    CellRendererEditingCanceledCallbackC    ,+    CellRendererEditingCanceledSignalInfo   ,+    afterCellRendererEditingCanceled        ,+    cellRendererEditingCanceledCallbackWrapper,+    cellRendererEditingCanceledClosure      ,+    mkCellRendererEditingCanceledCallback   ,+    noCellRendererEditingCanceledCallback   ,+    onCellRendererEditingCanceled           ,+++-- ** EditingStarted+    CellRendererEditingStartedCallback      ,+    CellRendererEditingStartedCallbackC     ,+    CellRendererEditingStartedSignalInfo    ,+    afterCellRendererEditingStarted         ,+    cellRendererEditingStartedCallbackWrapper,+    cellRendererEditingStartedClosure       ,+    mkCellRendererEditingStartedCallback    ,+    noCellRendererEditingStartedCallback    ,+    onCellRendererEditingStarted            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Cairo as Cairo++newtype CellRenderer = CellRenderer (ForeignPtr CellRenderer)+foreign import ccall "gtk_cell_renderer_get_type"+    c_gtk_cell_renderer_get_type :: IO GType++type instance ParentTypes CellRenderer = CellRendererParentTypes+type CellRendererParentTypes = '[GObject.Object]++instance GObject CellRenderer where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_get_type+    ++class GObject o => CellRendererK o+instance (GObject o, IsDescendantOf CellRenderer o) => CellRendererK o++toCellRenderer :: CellRendererK o => o -> IO CellRenderer+toCellRenderer = unsafeCastTo CellRenderer++noCellRenderer :: Maybe CellRenderer+noCellRenderer = Nothing++-- signal CellRenderer::editing-canceled+type CellRendererEditingCanceledCallback =+    IO ()++noCellRendererEditingCanceledCallback :: Maybe CellRendererEditingCanceledCallback+noCellRendererEditingCanceledCallback = Nothing++type CellRendererEditingCanceledCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererEditingCanceledCallback :: CellRendererEditingCanceledCallbackC -> IO (FunPtr CellRendererEditingCanceledCallbackC)++cellRendererEditingCanceledClosure :: CellRendererEditingCanceledCallback -> IO Closure+cellRendererEditingCanceledClosure cb = newCClosure =<< mkCellRendererEditingCanceledCallback wrapped+    where wrapped = cellRendererEditingCanceledCallbackWrapper cb++cellRendererEditingCanceledCallbackWrapper ::+    CellRendererEditingCanceledCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+cellRendererEditingCanceledCallbackWrapper _cb _ _ = do+    _cb ++onCellRendererEditingCanceled :: (GObject a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId+onCellRendererEditingCanceled obj cb = liftIO $ connectCellRendererEditingCanceled obj cb SignalConnectBefore+afterCellRendererEditingCanceled :: (GObject a, MonadIO m) => a -> CellRendererEditingCanceledCallback -> m SignalHandlerId+afterCellRendererEditingCanceled obj cb = connectCellRendererEditingCanceled obj cb SignalConnectAfter++connectCellRendererEditingCanceled :: (GObject a, MonadIO m) =>+                                      a -> CellRendererEditingCanceledCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererEditingCanceled obj cb after = liftIO $ do+    cb' <- mkCellRendererEditingCanceledCallback (cellRendererEditingCanceledCallbackWrapper cb)+    connectSignalFunPtr obj "editing-canceled" cb' after++-- signal CellRenderer::editing-started+type CellRendererEditingStartedCallback =+    CellEditable ->+    T.Text ->+    IO ()++noCellRendererEditingStartedCallback :: Maybe CellRendererEditingStartedCallback+noCellRendererEditingStartedCallback = Nothing++type CellRendererEditingStartedCallbackC =+    Ptr () ->                               -- object+    Ptr CellEditable ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererEditingStartedCallback :: CellRendererEditingStartedCallbackC -> IO (FunPtr CellRendererEditingStartedCallbackC)++cellRendererEditingStartedClosure :: CellRendererEditingStartedCallback -> IO Closure+cellRendererEditingStartedClosure cb = newCClosure =<< mkCellRendererEditingStartedCallback wrapped+    where wrapped = cellRendererEditingStartedCallbackWrapper cb++cellRendererEditingStartedCallbackWrapper ::+    CellRendererEditingStartedCallback ->+    Ptr () ->+    Ptr CellEditable ->+    CString ->+    Ptr () ->+    IO ()+cellRendererEditingStartedCallbackWrapper _cb _ editable path _ = do+    editable' <- (newObject CellEditable) editable+    path' <- cstringToText path+    _cb  editable' path'++onCellRendererEditingStarted :: (GObject a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId+onCellRendererEditingStarted obj cb = liftIO $ connectCellRendererEditingStarted obj cb SignalConnectBefore+afterCellRendererEditingStarted :: (GObject a, MonadIO m) => a -> CellRendererEditingStartedCallback -> m SignalHandlerId+afterCellRendererEditingStarted obj cb = connectCellRendererEditingStarted obj cb SignalConnectAfter++connectCellRendererEditingStarted :: (GObject a, MonadIO m) =>+                                     a -> CellRendererEditingStartedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererEditingStarted obj cb after = liftIO $ do+    cb' <- mkCellRendererEditingStartedCallback (cellRendererEditingStartedCallbackWrapper cb)+    connectSignalFunPtr obj "editing-started" cb' after++-- VVV Prop "cell-background"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setCellRendererCellBackground :: (MonadIO m, CellRendererK o) => o -> T.Text -> m ()+setCellRendererCellBackground obj val = liftIO $ setObjectPropertyString obj "cell-background" val++constructCellRendererCellBackground :: T.Text -> IO ([Char], GValue)+constructCellRendererCellBackground val = constructObjectPropertyString "cell-background" val++data CellRendererCellBackgroundPropertyInfo+instance AttrInfo CellRendererCellBackgroundPropertyInfo where+    type AttrAllowedOps CellRendererCellBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint CellRendererCellBackgroundPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererCellBackgroundPropertyInfo = CellRendererK+    type AttrGetType CellRendererCellBackgroundPropertyInfo = ()+    type AttrLabel CellRendererCellBackgroundPropertyInfo = "CellRenderer::cell-background"+    attrGet _ = undefined+    attrSet _ = setCellRendererCellBackground+    attrConstruct _ = constructCellRendererCellBackground++-- VVV Prop "cell-background-gdk"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererCellBackgroundGdk :: (MonadIO m, CellRendererK o) => o -> m Gdk.Color+getCellRendererCellBackgroundGdk obj = liftIO $ getObjectPropertyBoxed obj "cell-background-gdk" Gdk.Color++setCellRendererCellBackgroundGdk :: (MonadIO m, CellRendererK o) => o -> Gdk.Color -> m ()+setCellRendererCellBackgroundGdk obj val = liftIO $ setObjectPropertyBoxed obj "cell-background-gdk" val++constructCellRendererCellBackgroundGdk :: Gdk.Color -> IO ([Char], GValue)+constructCellRendererCellBackgroundGdk val = constructObjectPropertyBoxed "cell-background-gdk" val++data CellRendererCellBackgroundGdkPropertyInfo+instance AttrInfo CellRendererCellBackgroundGdkPropertyInfo where+    type AttrAllowedOps CellRendererCellBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint CellRendererCellBackgroundGdkPropertyInfo = CellRendererK+    type AttrGetType CellRendererCellBackgroundGdkPropertyInfo = Gdk.Color+    type AttrLabel CellRendererCellBackgroundGdkPropertyInfo = "CellRenderer::cell-background-gdk"+    attrGet _ = getCellRendererCellBackgroundGdk+    attrSet _ = setCellRendererCellBackgroundGdk+    attrConstruct _ = constructCellRendererCellBackgroundGdk++-- VVV Prop "cell-background-rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererCellBackgroundRgba :: (MonadIO m, CellRendererK o) => o -> m Gdk.RGBA+getCellRendererCellBackgroundRgba obj = liftIO $ getObjectPropertyBoxed obj "cell-background-rgba" Gdk.RGBA++setCellRendererCellBackgroundRgba :: (MonadIO m, CellRendererK o) => o -> Gdk.RGBA -> m ()+setCellRendererCellBackgroundRgba obj val = liftIO $ setObjectPropertyBoxed obj "cell-background-rgba" val++constructCellRendererCellBackgroundRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructCellRendererCellBackgroundRgba val = constructObjectPropertyBoxed "cell-background-rgba" val++data CellRendererCellBackgroundRgbaPropertyInfo+instance AttrInfo CellRendererCellBackgroundRgbaPropertyInfo where+    type AttrAllowedOps CellRendererCellBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint CellRendererCellBackgroundRgbaPropertyInfo = CellRendererK+    type AttrGetType CellRendererCellBackgroundRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel CellRendererCellBackgroundRgbaPropertyInfo = "CellRenderer::cell-background-rgba"+    attrGet _ = getCellRendererCellBackgroundRgba+    attrSet _ = setCellRendererCellBackgroundRgba+    attrConstruct _ = constructCellRendererCellBackgroundRgba++-- VVV Prop "cell-background-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererCellBackgroundSet :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererCellBackgroundSet obj = liftIO $ getObjectPropertyBool obj "cell-background-set"++setCellRendererCellBackgroundSet :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()+setCellRendererCellBackgroundSet obj val = liftIO $ setObjectPropertyBool obj "cell-background-set" val++constructCellRendererCellBackgroundSet :: Bool -> IO ([Char], GValue)+constructCellRendererCellBackgroundSet val = constructObjectPropertyBool "cell-background-set" val++data CellRendererCellBackgroundSetPropertyInfo+instance AttrInfo CellRendererCellBackgroundSetPropertyInfo where+    type AttrAllowedOps CellRendererCellBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererCellBackgroundSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererCellBackgroundSetPropertyInfo = CellRendererK+    type AttrGetType CellRendererCellBackgroundSetPropertyInfo = Bool+    type AttrLabel CellRendererCellBackgroundSetPropertyInfo = "CellRenderer::cell-background-set"+    attrGet _ = getCellRendererCellBackgroundSet+    attrSet _ = setCellRendererCellBackgroundSet+    attrConstruct _ = constructCellRendererCellBackgroundSet++-- VVV Prop "editing"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getCellRendererEditing :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererEditing obj = liftIO $ getObjectPropertyBool obj "editing"++data CellRendererEditingPropertyInfo+instance AttrInfo CellRendererEditingPropertyInfo where+    type AttrAllowedOps CellRendererEditingPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint CellRendererEditingPropertyInfo = (~) ()+    type AttrBaseTypeConstraint CellRendererEditingPropertyInfo = CellRendererK+    type AttrGetType CellRendererEditingPropertyInfo = Bool+    type AttrLabel CellRendererEditingPropertyInfo = "CellRenderer::editing"+    attrGet _ = getCellRendererEditing+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "height"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererHeight :: (MonadIO m, CellRendererK o) => o -> m Int32+getCellRendererHeight obj = liftIO $ getObjectPropertyCInt obj "height"++setCellRendererHeight :: (MonadIO m, CellRendererK o) => o -> Int32 -> m ()+setCellRendererHeight obj val = liftIO $ setObjectPropertyCInt obj "height" val++constructCellRendererHeight :: Int32 -> IO ([Char], GValue)+constructCellRendererHeight val = constructObjectPropertyCInt "height" val++data CellRendererHeightPropertyInfo+instance AttrInfo CellRendererHeightPropertyInfo where+    type AttrAllowedOps CellRendererHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererHeightPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererHeightPropertyInfo = CellRendererK+    type AttrGetType CellRendererHeightPropertyInfo = Int32+    type AttrLabel CellRendererHeightPropertyInfo = "CellRenderer::height"+    attrGet _ = getCellRendererHeight+    attrSet _ = setCellRendererHeight+    attrConstruct _ = constructCellRendererHeight++-- VVV Prop "is-expanded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererIsExpanded :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererIsExpanded obj = liftIO $ getObjectPropertyBool obj "is-expanded"++setCellRendererIsExpanded :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()+setCellRendererIsExpanded obj val = liftIO $ setObjectPropertyBool obj "is-expanded" val++constructCellRendererIsExpanded :: Bool -> IO ([Char], GValue)+constructCellRendererIsExpanded val = constructObjectPropertyBool "is-expanded" val++data CellRendererIsExpandedPropertyInfo+instance AttrInfo CellRendererIsExpandedPropertyInfo where+    type AttrAllowedOps CellRendererIsExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererIsExpandedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererIsExpandedPropertyInfo = CellRendererK+    type AttrGetType CellRendererIsExpandedPropertyInfo = Bool+    type AttrLabel CellRendererIsExpandedPropertyInfo = "CellRenderer::is-expanded"+    attrGet _ = getCellRendererIsExpanded+    attrSet _ = setCellRendererIsExpanded+    attrConstruct _ = constructCellRendererIsExpanded++-- VVV Prop "is-expander"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererIsExpander :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererIsExpander obj = liftIO $ getObjectPropertyBool obj "is-expander"++setCellRendererIsExpander :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()+setCellRendererIsExpander obj val = liftIO $ setObjectPropertyBool obj "is-expander" val++constructCellRendererIsExpander :: Bool -> IO ([Char], GValue)+constructCellRendererIsExpander val = constructObjectPropertyBool "is-expander" val++data CellRendererIsExpanderPropertyInfo+instance AttrInfo CellRendererIsExpanderPropertyInfo where+    type AttrAllowedOps CellRendererIsExpanderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererIsExpanderPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererIsExpanderPropertyInfo = CellRendererK+    type AttrGetType CellRendererIsExpanderPropertyInfo = Bool+    type AttrLabel CellRendererIsExpanderPropertyInfo = "CellRenderer::is-expander"+    attrGet _ = getCellRendererIsExpander+    attrSet _ = setCellRendererIsExpander+    attrConstruct _ = constructCellRendererIsExpander++-- VVV Prop "mode"+   -- Type: TInterface "Gtk" "CellRendererMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererMode :: (MonadIO m, CellRendererK o) => o -> m CellRendererMode+getCellRendererMode obj = liftIO $ getObjectPropertyEnum obj "mode"++setCellRendererMode :: (MonadIO m, CellRendererK o) => o -> CellRendererMode -> m ()+setCellRendererMode obj val = liftIO $ setObjectPropertyEnum obj "mode" val++constructCellRendererMode :: CellRendererMode -> IO ([Char], GValue)+constructCellRendererMode val = constructObjectPropertyEnum "mode" val++data CellRendererModePropertyInfo+instance AttrInfo CellRendererModePropertyInfo where+    type AttrAllowedOps CellRendererModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererModePropertyInfo = (~) CellRendererMode+    type AttrBaseTypeConstraint CellRendererModePropertyInfo = CellRendererK+    type AttrGetType CellRendererModePropertyInfo = CellRendererMode+    type AttrLabel CellRendererModePropertyInfo = "CellRenderer::mode"+    attrGet _ = getCellRendererMode+    attrSet _ = setCellRendererMode+    attrConstruct _ = constructCellRendererMode++-- VVV Prop "sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSensitive :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"++setCellRendererSensitive :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()+setCellRendererSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val++constructCellRendererSensitive :: Bool -> IO ([Char], GValue)+constructCellRendererSensitive val = constructObjectPropertyBool "sensitive" val++data CellRendererSensitivePropertyInfo+instance AttrInfo CellRendererSensitivePropertyInfo where+    type AttrAllowedOps CellRendererSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererSensitivePropertyInfo = CellRendererK+    type AttrGetType CellRendererSensitivePropertyInfo = Bool+    type AttrLabel CellRendererSensitivePropertyInfo = "CellRenderer::sensitive"+    attrGet _ = getCellRendererSensitive+    attrSet _ = setCellRendererSensitive+    attrConstruct _ = constructCellRendererSensitive++-- VVV Prop "visible"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererVisible :: (MonadIO m, CellRendererK o) => o -> m Bool+getCellRendererVisible obj = liftIO $ getObjectPropertyBool obj "visible"++setCellRendererVisible :: (MonadIO m, CellRendererK o) => o -> Bool -> m ()+setCellRendererVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val++constructCellRendererVisible :: Bool -> IO ([Char], GValue)+constructCellRendererVisible val = constructObjectPropertyBool "visible" val++data CellRendererVisiblePropertyInfo+instance AttrInfo CellRendererVisiblePropertyInfo where+    type AttrAllowedOps CellRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererVisiblePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererVisiblePropertyInfo = CellRendererK+    type AttrGetType CellRendererVisiblePropertyInfo = Bool+    type AttrLabel CellRendererVisiblePropertyInfo = "CellRenderer::visible"+    attrGet _ = getCellRendererVisible+    attrSet _ = setCellRendererVisible+    attrConstruct _ = constructCellRendererVisible++-- VVV Prop "width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererWidth :: (MonadIO m, CellRendererK o) => o -> m Int32+getCellRendererWidth obj = liftIO $ getObjectPropertyCInt obj "width"++setCellRendererWidth :: (MonadIO m, CellRendererK o) => o -> Int32 -> m ()+setCellRendererWidth obj val = liftIO $ setObjectPropertyCInt obj "width" val++constructCellRendererWidth :: Int32 -> IO ([Char], GValue)+constructCellRendererWidth val = constructObjectPropertyCInt "width" val++data CellRendererWidthPropertyInfo+instance AttrInfo CellRendererWidthPropertyInfo where+    type AttrAllowedOps CellRendererWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererWidthPropertyInfo = CellRendererK+    type AttrGetType CellRendererWidthPropertyInfo = Int32+    type AttrLabel CellRendererWidthPropertyInfo = "CellRenderer::width"+    attrGet _ = getCellRendererWidth+    attrSet _ = setCellRendererWidth+    attrConstruct _ = constructCellRendererWidth++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererXalign :: (MonadIO m, CellRendererK o) => o -> m Float+getCellRendererXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setCellRendererXalign :: (MonadIO m, CellRendererK o) => o -> Float -> m ()+setCellRendererXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructCellRendererXalign :: Float -> IO ([Char], GValue)+constructCellRendererXalign val = constructObjectPropertyFloat "xalign" val++data CellRendererXalignPropertyInfo+instance AttrInfo CellRendererXalignPropertyInfo where+    type AttrAllowedOps CellRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint CellRendererXalignPropertyInfo = CellRendererK+    type AttrGetType CellRendererXalignPropertyInfo = Float+    type AttrLabel CellRendererXalignPropertyInfo = "CellRenderer::xalign"+    attrGet _ = getCellRendererXalign+    attrSet _ = setCellRendererXalign+    attrConstruct _ = constructCellRendererXalign++-- VVV Prop "xpad"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererXpad :: (MonadIO m, CellRendererK o) => o -> m Word32+getCellRendererXpad obj = liftIO $ getObjectPropertyCUInt obj "xpad"++setCellRendererXpad :: (MonadIO m, CellRendererK o) => o -> Word32 -> m ()+setCellRendererXpad obj val = liftIO $ setObjectPropertyCUInt obj "xpad" val++constructCellRendererXpad :: Word32 -> IO ([Char], GValue)+constructCellRendererXpad val = constructObjectPropertyCUInt "xpad" val++data CellRendererXpadPropertyInfo+instance AttrInfo CellRendererXpadPropertyInfo where+    type AttrAllowedOps CellRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererXpadPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererXpadPropertyInfo = CellRendererK+    type AttrGetType CellRendererXpadPropertyInfo = Word32+    type AttrLabel CellRendererXpadPropertyInfo = "CellRenderer::xpad"+    attrGet _ = getCellRendererXpad+    attrSet _ = setCellRendererXpad+    attrConstruct _ = constructCellRendererXpad++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererYalign :: (MonadIO m, CellRendererK o) => o -> m Float+getCellRendererYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setCellRendererYalign :: (MonadIO m, CellRendererK o) => o -> Float -> m ()+setCellRendererYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructCellRendererYalign :: Float -> IO ([Char], GValue)+constructCellRendererYalign val = constructObjectPropertyFloat "yalign" val++data CellRendererYalignPropertyInfo+instance AttrInfo CellRendererYalignPropertyInfo where+    type AttrAllowedOps CellRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint CellRendererYalignPropertyInfo = CellRendererK+    type AttrGetType CellRendererYalignPropertyInfo = Float+    type AttrLabel CellRendererYalignPropertyInfo = "CellRenderer::yalign"+    attrGet _ = getCellRendererYalign+    attrSet _ = setCellRendererYalign+    attrConstruct _ = constructCellRendererYalign++-- VVV Prop "ypad"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererYpad :: (MonadIO m, CellRendererK o) => o -> m Word32+getCellRendererYpad obj = liftIO $ getObjectPropertyCUInt obj "ypad"++setCellRendererYpad :: (MonadIO m, CellRendererK o) => o -> Word32 -> m ()+setCellRendererYpad obj val = liftIO $ setObjectPropertyCUInt obj "ypad" val++constructCellRendererYpad :: Word32 -> IO ([Char], GValue)+constructCellRendererYpad val = constructObjectPropertyCUInt "ypad" val++data CellRendererYpadPropertyInfo+instance AttrInfo CellRendererYpadPropertyInfo where+    type AttrAllowedOps CellRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererYpadPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererYpadPropertyInfo = CellRendererK+    type AttrGetType CellRendererYpadPropertyInfo = Word32+    type AttrLabel CellRendererYpadPropertyInfo = "CellRenderer::ypad"+    attrGet _ = getCellRendererYpad+    attrSet _ = setCellRendererYpad+    attrConstruct _ = constructCellRendererYpad++type instance AttributeList CellRenderer = CellRendererAttributeList+type CellRendererAttributeList = ('[ '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++data CellRendererEditingCanceledSignalInfo+instance SignalInfo CellRendererEditingCanceledSignalInfo where+    type HaskellCallbackType CellRendererEditingCanceledSignalInfo = CellRendererEditingCanceledCallback+    connectSignal _ = connectCellRendererEditingCanceled++data CellRendererEditingStartedSignalInfo+instance SignalInfo CellRendererEditingStartedSignalInfo where+    type HaskellCallbackType CellRendererEditingStartedSignalInfo = CellRendererEditingStartedCallback+    connectSignal _ = connectCellRendererEditingStarted++type instance SignalList CellRenderer = CellRendererSignalList+type CellRendererSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRenderer::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_activate" gtk_cell_renderer_activate :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- path : TBasicType TUTF8+    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    IO CInt+++cellRendererActivate ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    Gdk.Event ->                            -- event+    b ->                                    -- widget+    T.Text ->                               -- path+    Gdk.Rectangle ->                        -- background_area+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    m Bool+cellRendererActivate _obj event widget path background_area cell_area flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    let widget' = unsafeManagedPtrCastPtr widget+    path' <- textToCString path+    let background_area' = unsafeManagedPtrGetPtr background_area+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    result <- gtk_cell_renderer_activate _obj' event' widget' path' background_area' cell_area' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    touchManagedPtr widget+    touchManagedPtr background_area+    touchManagedPtr cell_area+    freeMem path'+    return result'++-- method CellRenderer::get_aligned_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "aligned_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_aligned_area" gtk_cell_renderer_get_aligned_area :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- aligned_area : TInterface "Gdk" "Rectangle"+    IO ()+++cellRendererGetAlignedArea ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    [CellRendererState] ->                  -- flags+    Gdk.Rectangle ->                        -- cell_area+    m (Gdk.Rectangle)+cellRendererGetAlignedArea _obj widget flags cell_area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let flags' = gflagsToWord flags+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    aligned_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_cell_renderer_get_aligned_area _obj' widget' flags' cell_area' aligned_area+    aligned_area' <- (wrapBoxed Gdk.Rectangle) aligned_area+    touchManagedPtr _obj+    touchManagedPtr widget+    touchManagedPtr cell_area+    return aligned_area'++-- method CellRenderer::get_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_alignment" gtk_cell_renderer_get_alignment :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr CFloat ->                           -- xalign : TBasicType TFloat+    Ptr CFloat ->                           -- yalign : TBasicType TFloat+    IO ()+++cellRendererGetAlignment ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m (Float,Float)+cellRendererGetAlignment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xalign <- allocMem :: IO (Ptr CFloat)+    yalign <- allocMem :: IO (Ptr CFloat)+    gtk_cell_renderer_get_alignment _obj' xalign yalign+    xalign' <- peek xalign+    let xalign'' = realToFrac xalign'+    yalign' <- peek yalign+    let yalign'' = realToFrac yalign'+    touchManagedPtr _obj+    freeMem xalign+    freeMem yalign+    return (xalign'', yalign'')++-- method CellRenderer::get_fixed_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_fixed_size" gtk_cell_renderer_get_fixed_size :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO ()+++cellRendererGetFixedSize ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+cellRendererGetFixedSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_fixed_size _obj' width height+    width' <- peek width+    height' <- peek height+    touchManagedPtr _obj+    freeMem width+    freeMem height+    return (width', height')++-- method CellRenderer::get_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_padding" gtk_cell_renderer_get_padding :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Int32 ->                            -- xpad : TBasicType TInt32+    Ptr Int32 ->                            -- ypad : TBasicType TInt32+    IO ()+++cellRendererGetPadding ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+cellRendererGetPadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xpad <- allocMem :: IO (Ptr Int32)+    ypad <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_padding _obj' xpad ypad+    xpad' <- peek xpad+    ypad' <- peek ypad+    touchManagedPtr _obj+    freeMem xpad+    freeMem ypad+    return (xpad', ypad')++-- method CellRenderer::get_preferred_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_preferred_height" gtk_cell_renderer_get_preferred_height :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Int32 ->                            -- minimum_size : TBasicType TInt32+    Ptr Int32 ->                            -- natural_size : TBasicType TInt32+    IO ()+++cellRendererGetPreferredHeight ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m (Int32,Int32)+cellRendererGetPreferredHeight _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_size <- allocMem :: IO (Ptr Int32)+    natural_size <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_preferred_height _obj' widget' minimum_size natural_size+    minimum_size' <- peek minimum_size+    natural_size' <- peek natural_size+    touchManagedPtr _obj+    touchManagedPtr widget+    freeMem minimum_size+    freeMem natural_size+    return (minimum_size', natural_size')++-- method CellRenderer::get_preferred_height_for_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", 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 "gtk_cell_renderer_get_preferred_height_for_width" gtk_cell_renderer_get_preferred_height_for_width :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- width : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_height : TBasicType TInt32+    Ptr Int32 ->                            -- natural_height : TBasicType TInt32+    IO ()+++cellRendererGetPreferredHeightForWidth ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Int32 ->                                -- width+    m (Int32,Int32)+cellRendererGetPreferredHeightForWidth _obj widget width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_height <- allocMem :: IO (Ptr Int32)+    natural_height <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_preferred_height_for_width _obj' widget' width minimum_height natural_height+    minimum_height' <- peek minimum_height+    natural_height' <- peek natural_height+    touchManagedPtr _obj+    touchManagedPtr widget+    freeMem minimum_height+    freeMem natural_height+    return (minimum_height', natural_height')++-- method CellRenderer::get_preferred_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TInterface "Gtk" "Requisition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "natural_size", argType = TInterface "Gtk" "Requisition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_preferred_size" gtk_cell_renderer_get_preferred_size :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Requisition ->                      -- minimum_size : TInterface "Gtk" "Requisition"+    Ptr Requisition ->                      -- natural_size : TInterface "Gtk" "Requisition"+    IO ()+++cellRendererGetPreferredSize ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m (Requisition,Requisition)+cellRendererGetPreferredSize _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_size <- callocBoxedBytes 8 :: IO (Ptr Requisition)+    natural_size <- callocBoxedBytes 8 :: IO (Ptr Requisition)+    gtk_cell_renderer_get_preferred_size _obj' widget' minimum_size natural_size+    minimum_size' <- (wrapBoxed Requisition) minimum_size+    natural_size' <- (wrapBoxed Requisition) natural_size+    touchManagedPtr _obj+    touchManagedPtr widget+    return (minimum_size', natural_size')++-- method CellRenderer::get_preferred_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_preferred_width" gtk_cell_renderer_get_preferred_width :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Int32 ->                            -- minimum_size : TBasicType TInt32+    Ptr Int32 ->                            -- natural_size : TBasicType TInt32+    IO ()+++cellRendererGetPreferredWidth ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m (Int32,Int32)+cellRendererGetPreferredWidth _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_size <- allocMem :: IO (Ptr Int32)+    natural_size <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_preferred_width _obj' widget' minimum_size natural_size+    minimum_size' <- peek minimum_size+    natural_size' <- peek natural_size+    touchManagedPtr _obj+    touchManagedPtr widget+    freeMem minimum_size+    freeMem natural_size+    return (minimum_size', natural_size')++-- method CellRenderer::get_preferred_width_for_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minimum_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "natural_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_cell_renderer_get_preferred_width_for_height" gtk_cell_renderer_get_preferred_width_for_height :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- height : TBasicType TInt32+    Ptr Int32 ->                            -- minimum_width : TBasicType TInt32+    Ptr Int32 ->                            -- natural_width : TBasicType TInt32+    IO ()+++cellRendererGetPreferredWidthForHeight ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Int32 ->                                -- height+    m (Int32,Int32)+cellRendererGetPreferredWidthForHeight _obj widget height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    minimum_width <- allocMem :: IO (Ptr Int32)+    natural_width <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_preferred_width_for_height _obj' widget' height minimum_width natural_width+    minimum_width' <- peek minimum_width+    natural_width' <- peek natural_width+    touchManagedPtr _obj+    touchManagedPtr widget+    freeMem minimum_width+    freeMem natural_width+    return (minimum_width', natural_width')++-- method CellRenderer::get_request_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SizeRequestMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_request_mode" gtk_cell_renderer_get_request_mode :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    IO CUInt+++cellRendererGetRequestMode ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m SizeRequestMode+cellRendererGetRequestMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_get_request_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method CellRenderer::get_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_sensitive" gtk_cell_renderer_get_sensitive :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    IO CInt+++cellRendererGetSensitive ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererGetSensitive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_get_sensitive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRenderer::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x_offset", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y_offset", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_size" gtk_cell_renderer_get_size :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    Ptr Int32 ->                            -- x_offset : TBasicType TInt32+    Ptr Int32 ->                            -- y_offset : TBasicType TInt32+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO ()++{-# DEPRECATED cellRendererGetSize ["(Since version 3.0)","Use gtk_cell_renderer_get_preferred_size() instead."]#-}+cellRendererGetSize ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Maybe (Gdk.Rectangle) ->                -- cell_area+    m (Int32,Int32,Int32,Int32)+cellRendererGetSize _obj widget cell_area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    maybeCell_area <- case cell_area of+        Nothing -> return nullPtr+        Just jCell_area -> do+            let jCell_area' = unsafeManagedPtrGetPtr jCell_area+            return jCell_area'+    x_offset <- allocMem :: IO (Ptr Int32)+    y_offset <- allocMem :: IO (Ptr Int32)+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    gtk_cell_renderer_get_size _obj' widget' maybeCell_area x_offset y_offset width height+    x_offset' <- peek x_offset+    y_offset' <- peek y_offset+    width' <- peek width+    height' <- peek height+    touchManagedPtr _obj+    touchManagedPtr widget+    whenJust cell_area touchManagedPtr+    freeMem x_offset+    freeMem y_offset+    freeMem width+    freeMem height+    return (x_offset', y_offset', width', height')++-- method CellRenderer::get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_state", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_state", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "StateFlags"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_state" gtk_cell_renderer_get_state :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CUInt ->                                -- cell_state : TInterface "Gtk" "CellRendererState"+    IO CUInt+++cellRendererGetState ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    [CellRendererState] ->                  -- cell_state+    m [StateFlags]+cellRendererGetState _obj widget cell_state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let cell_state' = gflagsToWord cell_state+    result <- gtk_cell_renderer_get_state _obj' widget' cell_state'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    touchManagedPtr widget+    return result'++-- method CellRenderer::get_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_get_visible" gtk_cell_renderer_get_visible :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    IO CInt+++cellRendererGetVisible ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererGetVisible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_get_visible _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRenderer::is_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_is_activatable" gtk_cell_renderer_is_activatable :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    IO CInt+++cellRendererIsActivatable ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererIsActivatable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_is_activatable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRenderer::render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_render" gtk_cell_renderer_render :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    IO ()+++cellRendererRender ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cr+    b ->                                    -- widget+    Gdk.Rectangle ->                        -- background_area+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    m ()+cellRendererRender _obj cr widget background_area cell_area flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cr' = unsafeManagedPtrGetPtr cr+    let widget' = unsafeManagedPtrCastPtr widget+    let background_area' = unsafeManagedPtrGetPtr background_area+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    gtk_cell_renderer_render _obj' cr' widget' background_area' cell_area' flags'+    touchManagedPtr _obj+    touchManagedPtr cr+    touchManagedPtr widget+    touchManagedPtr background_area+    touchManagedPtr cell_area+    return ()++-- method CellRenderer::set_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_set_alignment" gtk_cell_renderer_set_alignment :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    IO ()+++cellRendererSetAlignment ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    m ()+cellRendererSetAlignment _obj xalign yalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    gtk_cell_renderer_set_alignment _obj' xalign' yalign'+    touchManagedPtr _obj+    return ()++-- method CellRenderer::set_fixed_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_cell_renderer_set_fixed_size" gtk_cell_renderer_set_fixed_size :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()+++cellRendererSetFixedSize ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+cellRendererSetFixedSize _obj width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_renderer_set_fixed_size _obj' width height+    touchManagedPtr _obj+    return ()++-- method CellRenderer::set_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", 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 "gtk_cell_renderer_set_padding" gtk_cell_renderer_set_padding :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Int32 ->                                -- xpad : TBasicType TInt32+    Int32 ->                                -- ypad : TBasicType TInt32+    IO ()+++cellRendererSetPadding ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- xpad+    Int32 ->                                -- ypad+    m ()+cellRendererSetPadding _obj xpad ypad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_renderer_set_padding _obj' xpad ypad+    touchManagedPtr _obj+    return ()++-- method CellRenderer::set_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", 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 "gtk_cell_renderer_set_sensitive" gtk_cell_renderer_set_sensitive :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- sensitive : TBasicType TBoolean+    IO ()+++cellRendererSetSensitive ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- sensitive+    m ()+cellRendererSetSensitive _obj sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitive' = (fromIntegral . fromEnum) sensitive+    gtk_cell_renderer_set_sensitive _obj' sensitive'+    touchManagedPtr _obj+    return ()++-- method CellRenderer::set_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", 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 "gtk_cell_renderer_set_visible" gtk_cell_renderer_set_visible :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- visible : TBasicType TBoolean+    IO ()+++cellRendererSetVisible ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible+    m ()+cellRendererSetVisible _obj visible = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible' = (fromIntegral . fromEnum) visible+    gtk_cell_renderer_set_visible _obj' visible'+    touchManagedPtr _obj+    return ()++-- method CellRenderer::start_editing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 = "background_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "CellRendererState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellEditable"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_start_editing" gtk_cell_renderer_start_editing :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CString ->                              -- path : TBasicType TUTF8+    Ptr Gdk.Rectangle ->                    -- background_area : TInterface "Gdk" "Rectangle"+    Ptr Gdk.Rectangle ->                    -- cell_area : TInterface "Gdk" "Rectangle"+    CUInt ->                                -- flags : TInterface "Gtk" "CellRendererState"+    IO (Ptr CellEditable)+++cellRendererStartEditing ::+    (MonadIO m, CellRendererK a, WidgetK b) =>+    a ->                                    -- _obj+    Gdk.Event ->                            -- event+    b ->                                    -- widget+    T.Text ->                               -- path+    Gdk.Rectangle ->                        -- background_area+    Gdk.Rectangle ->                        -- cell_area+    [CellRendererState] ->                  -- flags+    m CellEditable+cellRendererStartEditing _obj event widget path background_area cell_area flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    let widget' = unsafeManagedPtrCastPtr widget+    path' <- textToCString path+    let background_area' = unsafeManagedPtrGetPtr background_area+    let cell_area' = unsafeManagedPtrGetPtr cell_area+    let flags' = gflagsToWord flags+    result <- gtk_cell_renderer_start_editing _obj' event' widget' path' background_area' cell_area' flags'+    checkUnexpectedReturnNULL "gtk_cell_renderer_start_editing" result+    result' <- (newObject CellEditable) result+    touchManagedPtr _obj+    touchManagedPtr event+    touchManagedPtr widget+    touchManagedPtr background_area+    touchManagedPtr cell_area+    freeMem path'+    return result'++-- method CellRenderer::stop_editing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "canceled", 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 "gtk_cell_renderer_stop_editing" gtk_cell_renderer_stop_editing :: +    Ptr CellRenderer ->                     -- _obj : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- canceled : TBasicType TBoolean+    IO ()+++cellRendererStopEditing ::+    (MonadIO m, CellRendererK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- canceled+    m ()+cellRendererStopEditing _obj canceled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let canceled' = (fromIntegral . fromEnum) canceled+    gtk_cell_renderer_stop_editing _obj' canceled'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellRenderer.hs-boot view
@@ -0,0 +1,31 @@+module GI.Gtk.Objects.CellRenderer where++import Prelude ()+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 CellRenderer = CellRenderer (ForeignPtr CellRenderer)+instance GObject CellRenderer where+class GObject o => CellRendererK o+instance (GObject o, IsDescendantOf CellRenderer o) => CellRendererK o+data CellRendererCellBackgroundPropertyInfo+data CellRendererCellBackgroundGdkPropertyInfo+data CellRendererCellBackgroundRgbaPropertyInfo+data CellRendererCellBackgroundSetPropertyInfo+data CellRendererEditingPropertyInfo+data CellRendererHeightPropertyInfo+data CellRendererIsExpandedPropertyInfo+data CellRendererIsExpanderPropertyInfo+data CellRendererModePropertyInfo+data CellRendererSensitivePropertyInfo+data CellRendererVisiblePropertyInfo+data CellRendererWidthPropertyInfo+data CellRendererXalignPropertyInfo+data CellRendererXpadPropertyInfo+data CellRendererYalignPropertyInfo+data CellRendererYpadPropertyInfo+data CellRendererEditingCanceledSignalInfo+data CellRendererEditingStartedSignalInfo
+ GI/Gtk/Objects/CellRendererAccel.hs view
@@ -0,0 +1,346 @@++{- |+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.Gtk.Objects.CellRendererAccel+    ( ++-- * Exported types+    CellRendererAccel(..)                   ,+    CellRendererAccelK                      ,+    toCellRendererAccel                     ,+    noCellRendererAccel                     ,+++ -- * Methods+-- ** cellRendererAccelNew+    cellRendererAccelNew                    ,+++++ -- * Properties+-- ** AccelKey+    CellRendererAccelAccelKeyPropertyInfo   ,+    constructCellRendererAccelAccelKey      ,+    getCellRendererAccelAccelKey            ,+    setCellRendererAccelAccelKey            ,+++-- ** AccelMode+    CellRendererAccelAccelModePropertyInfo  ,+    constructCellRendererAccelAccelMode     ,+    getCellRendererAccelAccelMode           ,+    setCellRendererAccelAccelMode           ,+++-- ** AccelMods+    CellRendererAccelAccelModsPropertyInfo  ,+    constructCellRendererAccelAccelMods     ,+    getCellRendererAccelAccelMods           ,+    setCellRendererAccelAccelMods           ,+++-- ** Keycode+    CellRendererAccelKeycodePropertyInfo    ,+    constructCellRendererAccelKeycode       ,+    getCellRendererAccelKeycode             ,+    setCellRendererAccelKeycode             ,+++++ -- * Signals+-- ** AccelCleared+    CellRendererAccelAccelClearedCallback   ,+    CellRendererAccelAccelClearedCallbackC  ,+    CellRendererAccelAccelClearedSignalInfo ,+    afterCellRendererAccelAccelCleared      ,+    cellRendererAccelAccelClearedCallbackWrapper,+    cellRendererAccelAccelClearedClosure    ,+    mkCellRendererAccelAccelClearedCallback ,+    noCellRendererAccelAccelClearedCallback ,+    onCellRendererAccelAccelCleared         ,+++-- ** AccelEdited+    CellRendererAccelAccelEditedCallback    ,+    CellRendererAccelAccelEditedCallbackC   ,+    CellRendererAccelAccelEditedSignalInfo  ,+    afterCellRendererAccelAccelEdited       ,+    cellRendererAccelAccelEditedCallbackWrapper,+    cellRendererAccelAccelEditedClosure     ,+    mkCellRendererAccelAccelEditedCallback  ,+    noCellRendererAccelAccelEditedCallback  ,+    onCellRendererAccelAccelEdited          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype CellRendererAccel = CellRendererAccel (ForeignPtr CellRendererAccel)+foreign import ccall "gtk_cell_renderer_accel_get_type"+    c_gtk_cell_renderer_accel_get_type :: IO GType++type instance ParentTypes CellRendererAccel = CellRendererAccelParentTypes+type CellRendererAccelParentTypes = '[CellRendererText, CellRenderer, GObject.Object]++instance GObject CellRendererAccel where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_accel_get_type+    ++class GObject o => CellRendererAccelK o+instance (GObject o, IsDescendantOf CellRendererAccel o) => CellRendererAccelK o++toCellRendererAccel :: CellRendererAccelK o => o -> IO CellRendererAccel+toCellRendererAccel = unsafeCastTo CellRendererAccel++noCellRendererAccel :: Maybe CellRendererAccel+noCellRendererAccel = Nothing++-- signal CellRendererAccel::accel-cleared+type CellRendererAccelAccelClearedCallback =+    T.Text ->+    IO ()++noCellRendererAccelAccelClearedCallback :: Maybe CellRendererAccelAccelClearedCallback+noCellRendererAccelAccelClearedCallback = Nothing++type CellRendererAccelAccelClearedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererAccelAccelClearedCallback :: CellRendererAccelAccelClearedCallbackC -> IO (FunPtr CellRendererAccelAccelClearedCallbackC)++cellRendererAccelAccelClearedClosure :: CellRendererAccelAccelClearedCallback -> IO Closure+cellRendererAccelAccelClearedClosure cb = newCClosure =<< mkCellRendererAccelAccelClearedCallback wrapped+    where wrapped = cellRendererAccelAccelClearedCallbackWrapper cb++cellRendererAccelAccelClearedCallbackWrapper ::+    CellRendererAccelAccelClearedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+cellRendererAccelAccelClearedCallbackWrapper _cb _ path_string _ = do+    path_string' <- cstringToText path_string+    _cb  path_string'++onCellRendererAccelAccelCleared :: (GObject a, MonadIO m) => a -> CellRendererAccelAccelClearedCallback -> m SignalHandlerId+onCellRendererAccelAccelCleared obj cb = liftIO $ connectCellRendererAccelAccelCleared obj cb SignalConnectBefore+afterCellRendererAccelAccelCleared :: (GObject a, MonadIO m) => a -> CellRendererAccelAccelClearedCallback -> m SignalHandlerId+afterCellRendererAccelAccelCleared obj cb = connectCellRendererAccelAccelCleared obj cb SignalConnectAfter++connectCellRendererAccelAccelCleared :: (GObject a, MonadIO m) =>+                                        a -> CellRendererAccelAccelClearedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererAccelAccelCleared obj cb after = liftIO $ do+    cb' <- mkCellRendererAccelAccelClearedCallback (cellRendererAccelAccelClearedCallbackWrapper cb)+    connectSignalFunPtr obj "accel-cleared" cb' after++-- signal CellRendererAccel::accel-edited+type CellRendererAccelAccelEditedCallback =+    T.Text ->+    Word32 ->+    [Gdk.ModifierType] ->+    Word32 ->+    IO ()++noCellRendererAccelAccelEditedCallback :: Maybe CellRendererAccelAccelEditedCallback+noCellRendererAccelAccelEditedCallback = Nothing++type CellRendererAccelAccelEditedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Word32 ->+    CUInt ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererAccelAccelEditedCallback :: CellRendererAccelAccelEditedCallbackC -> IO (FunPtr CellRendererAccelAccelEditedCallbackC)++cellRendererAccelAccelEditedClosure :: CellRendererAccelAccelEditedCallback -> IO Closure+cellRendererAccelAccelEditedClosure cb = newCClosure =<< mkCellRendererAccelAccelEditedCallback wrapped+    where wrapped = cellRendererAccelAccelEditedCallbackWrapper cb++cellRendererAccelAccelEditedCallbackWrapper ::+    CellRendererAccelAccelEditedCallback ->+    Ptr () ->+    CString ->+    Word32 ->+    CUInt ->+    Word32 ->+    Ptr () ->+    IO ()+cellRendererAccelAccelEditedCallbackWrapper _cb _ path_string accel_key accel_mods hardware_keycode _ = do+    path_string' <- cstringToText path_string+    let accel_mods' = wordToGFlags accel_mods+    _cb  path_string' accel_key accel_mods' hardware_keycode++onCellRendererAccelAccelEdited :: (GObject a, MonadIO m) => a -> CellRendererAccelAccelEditedCallback -> m SignalHandlerId+onCellRendererAccelAccelEdited obj cb = liftIO $ connectCellRendererAccelAccelEdited obj cb SignalConnectBefore+afterCellRendererAccelAccelEdited :: (GObject a, MonadIO m) => a -> CellRendererAccelAccelEditedCallback -> m SignalHandlerId+afterCellRendererAccelAccelEdited obj cb = connectCellRendererAccelAccelEdited obj cb SignalConnectAfter++connectCellRendererAccelAccelEdited :: (GObject a, MonadIO m) =>+                                       a -> CellRendererAccelAccelEditedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererAccelAccelEdited obj cb after = liftIO $ do+    cb' <- mkCellRendererAccelAccelEditedCallback (cellRendererAccelAccelEditedCallbackWrapper cb)+    connectSignalFunPtr obj "accel-edited" cb' after++-- VVV Prop "accel-key"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererAccelAccelKey :: (MonadIO m, CellRendererAccelK o) => o -> m Word32+getCellRendererAccelAccelKey obj = liftIO $ getObjectPropertyCUInt obj "accel-key"++setCellRendererAccelAccelKey :: (MonadIO m, CellRendererAccelK o) => o -> Word32 -> m ()+setCellRendererAccelAccelKey obj val = liftIO $ setObjectPropertyCUInt obj "accel-key" val++constructCellRendererAccelAccelKey :: Word32 -> IO ([Char], GValue)+constructCellRendererAccelAccelKey val = constructObjectPropertyCUInt "accel-key" val++data CellRendererAccelAccelKeyPropertyInfo+instance AttrInfo CellRendererAccelAccelKeyPropertyInfo where+    type AttrAllowedOps CellRendererAccelAccelKeyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererAccelAccelKeyPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererAccelAccelKeyPropertyInfo = CellRendererAccelK+    type AttrGetType CellRendererAccelAccelKeyPropertyInfo = Word32+    type AttrLabel CellRendererAccelAccelKeyPropertyInfo = "CellRendererAccel::accel-key"+    attrGet _ = getCellRendererAccelAccelKey+    attrSet _ = setCellRendererAccelAccelKey+    attrConstruct _ = constructCellRendererAccelAccelKey++-- VVV Prop "accel-mode"+   -- Type: TInterface "Gtk" "CellRendererAccelMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererAccelAccelMode :: (MonadIO m, CellRendererAccelK o) => o -> m CellRendererAccelMode+getCellRendererAccelAccelMode obj = liftIO $ getObjectPropertyEnum obj "accel-mode"++setCellRendererAccelAccelMode :: (MonadIO m, CellRendererAccelK o) => o -> CellRendererAccelMode -> m ()+setCellRendererAccelAccelMode obj val = liftIO $ setObjectPropertyEnum obj "accel-mode" val++constructCellRendererAccelAccelMode :: CellRendererAccelMode -> IO ([Char], GValue)+constructCellRendererAccelAccelMode val = constructObjectPropertyEnum "accel-mode" val++data CellRendererAccelAccelModePropertyInfo+instance AttrInfo CellRendererAccelAccelModePropertyInfo where+    type AttrAllowedOps CellRendererAccelAccelModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererAccelAccelModePropertyInfo = (~) CellRendererAccelMode+    type AttrBaseTypeConstraint CellRendererAccelAccelModePropertyInfo = CellRendererAccelK+    type AttrGetType CellRendererAccelAccelModePropertyInfo = CellRendererAccelMode+    type AttrLabel CellRendererAccelAccelModePropertyInfo = "CellRendererAccel::accel-mode"+    attrGet _ = getCellRendererAccelAccelMode+    attrSet _ = setCellRendererAccelAccelMode+    attrConstruct _ = constructCellRendererAccelAccelMode++-- VVV Prop "accel-mods"+   -- Type: TInterface "Gdk" "ModifierType"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererAccelAccelMods :: (MonadIO m, CellRendererAccelK o) => o -> m [Gdk.ModifierType]+getCellRendererAccelAccelMods obj = liftIO $ getObjectPropertyFlags obj "accel-mods"++setCellRendererAccelAccelMods :: (MonadIO m, CellRendererAccelK o) => o -> [Gdk.ModifierType] -> m ()+setCellRendererAccelAccelMods obj val = liftIO $ setObjectPropertyFlags obj "accel-mods" val++constructCellRendererAccelAccelMods :: [Gdk.ModifierType] -> IO ([Char], GValue)+constructCellRendererAccelAccelMods val = constructObjectPropertyFlags "accel-mods" val++data CellRendererAccelAccelModsPropertyInfo+instance AttrInfo CellRendererAccelAccelModsPropertyInfo where+    type AttrAllowedOps CellRendererAccelAccelModsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererAccelAccelModsPropertyInfo = (~) [Gdk.ModifierType]+    type AttrBaseTypeConstraint CellRendererAccelAccelModsPropertyInfo = CellRendererAccelK+    type AttrGetType CellRendererAccelAccelModsPropertyInfo = [Gdk.ModifierType]+    type AttrLabel CellRendererAccelAccelModsPropertyInfo = "CellRendererAccel::accel-mods"+    attrGet _ = getCellRendererAccelAccelMods+    attrSet _ = setCellRendererAccelAccelMods+    attrConstruct _ = constructCellRendererAccelAccelMods++-- VVV Prop "keycode"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererAccelKeycode :: (MonadIO m, CellRendererAccelK o) => o -> m Word32+getCellRendererAccelKeycode obj = liftIO $ getObjectPropertyCUInt obj "keycode"++setCellRendererAccelKeycode :: (MonadIO m, CellRendererAccelK o) => o -> Word32 -> m ()+setCellRendererAccelKeycode obj val = liftIO $ setObjectPropertyCUInt obj "keycode" val++constructCellRendererAccelKeycode :: Word32 -> IO ([Char], GValue)+constructCellRendererAccelKeycode val = constructObjectPropertyCUInt "keycode" val++data CellRendererAccelKeycodePropertyInfo+instance AttrInfo CellRendererAccelKeycodePropertyInfo where+    type AttrAllowedOps CellRendererAccelKeycodePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererAccelKeycodePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererAccelKeycodePropertyInfo = CellRendererAccelK+    type AttrGetType CellRendererAccelKeycodePropertyInfo = Word32+    type AttrLabel CellRendererAccelKeycodePropertyInfo = "CellRendererAccel::keycode"+    attrGet _ = getCellRendererAccelKeycode+    attrSet _ = setCellRendererAccelKeycode+    attrConstruct _ = constructCellRendererAccelKeycode++type instance AttributeList CellRendererAccel = CellRendererAccelAttributeList+type CellRendererAccelAttributeList = ('[ '("accel-key", CellRendererAccelAccelKeyPropertyInfo), '("accel-mode", CellRendererAccelAccelModePropertyInfo), '("accel-mods", CellRendererAccelAccelModsPropertyInfo), '("align-set", CellRendererTextAlignSetPropertyInfo), '("alignment", CellRendererTextAlignmentPropertyInfo), '("attributes", CellRendererTextAttributesPropertyInfo), '("background", CellRendererTextBackgroundPropertyInfo), '("background-gdk", CellRendererTextBackgroundGdkPropertyInfo), '("background-rgba", CellRendererTextBackgroundRgbaPropertyInfo), '("background-set", CellRendererTextBackgroundSetPropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editable", CellRendererTextEditablePropertyInfo), '("editable-set", CellRendererTextEditableSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("ellipsize", CellRendererTextEllipsizePropertyInfo), '("ellipsize-set", CellRendererTextEllipsizeSetPropertyInfo), '("family", CellRendererTextFamilyPropertyInfo), '("family-set", CellRendererTextFamilySetPropertyInfo), '("font", CellRendererTextFontPropertyInfo), '("font-desc", CellRendererTextFontDescPropertyInfo), '("foreground", CellRendererTextForegroundPropertyInfo), '("foreground-gdk", CellRendererTextForegroundGdkPropertyInfo), '("foreground-rgba", CellRendererTextForegroundRgbaPropertyInfo), '("foreground-set", CellRendererTextForegroundSetPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("keycode", CellRendererAccelKeycodePropertyInfo), '("language", CellRendererTextLanguagePropertyInfo), '("language-set", CellRendererTextLanguageSetPropertyInfo), '("markup", CellRendererTextMarkupPropertyInfo), '("max-width-chars", CellRendererTextMaxWidthCharsPropertyInfo), '("mode", CellRendererModePropertyInfo), '("placeholder-text", CellRendererTextPlaceholderTextPropertyInfo), '("rise", CellRendererTextRisePropertyInfo), '("rise-set", CellRendererTextRiseSetPropertyInfo), '("scale", CellRendererTextScalePropertyInfo), '("scale-set", CellRendererTextScaleSetPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("single-paragraph-mode", CellRendererTextSingleParagraphModePropertyInfo), '("size", CellRendererTextSizePropertyInfo), '("size-points", CellRendererTextSizePointsPropertyInfo), '("size-set", CellRendererTextSizeSetPropertyInfo), '("stretch", CellRendererTextStretchPropertyInfo), '("stretch-set", CellRendererTextStretchSetPropertyInfo), '("strikethrough", CellRendererTextStrikethroughPropertyInfo), '("strikethrough-set", CellRendererTextStrikethroughSetPropertyInfo), '("style", CellRendererTextStylePropertyInfo), '("style-set", CellRendererTextStyleSetPropertyInfo), '("text", CellRendererTextTextPropertyInfo), '("underline", CellRendererTextUnderlinePropertyInfo), '("underline-set", CellRendererTextUnderlineSetPropertyInfo), '("variant", CellRendererTextVariantPropertyInfo), '("variant-set", CellRendererTextVariantSetPropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("weight", CellRendererTextWeightPropertyInfo), '("weight-set", CellRendererTextWeightSetPropertyInfo), '("width", CellRendererWidthPropertyInfo), '("width-chars", CellRendererTextWidthCharsPropertyInfo), '("wrap-mode", CellRendererTextWrapModePropertyInfo), '("wrap-width", CellRendererTextWrapWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++data CellRendererAccelAccelClearedSignalInfo+instance SignalInfo CellRendererAccelAccelClearedSignalInfo where+    type HaskellCallbackType CellRendererAccelAccelClearedSignalInfo = CellRendererAccelAccelClearedCallback+    connectSignal _ = connectCellRendererAccelAccelCleared++data CellRendererAccelAccelEditedSignalInfo+instance SignalInfo CellRendererAccelAccelEditedSignalInfo where+    type HaskellCallbackType CellRendererAccelAccelEditedSignalInfo = CellRendererAccelAccelEditedCallback+    connectSignal _ = connectCellRendererAccelAccelEdited++type instance SignalList CellRendererAccel = CellRendererAccelSignalList+type CellRendererAccelSignalList = ('[ '("accel-cleared", CellRendererAccelAccelClearedSignalInfo), '("accel-edited", CellRendererAccelAccelEditedSignalInfo), '("edited", CellRendererTextEditedSignalInfo), '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererAccel::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererAccel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_accel_new" gtk_cell_renderer_accel_new :: +    IO (Ptr CellRendererAccel)+++cellRendererAccelNew ::+    (MonadIO m) =>+    m CellRendererAccel+cellRendererAccelNew  = liftIO $ do+    result <- gtk_cell_renderer_accel_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_accel_new" result+    result' <- (newObject CellRendererAccel) result+    return result'++
+ GI/Gtk/Objects/CellRendererAccel.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.CellRendererAccel where++import Prelude ()+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 CellRendererAccel = CellRendererAccel (ForeignPtr CellRendererAccel)+instance GObject CellRendererAccel where+class GObject o => CellRendererAccelK o+instance (GObject o, IsDescendantOf CellRendererAccel o) => CellRendererAccelK o+data CellRendererAccelAccelKeyPropertyInfo+data CellRendererAccelAccelModePropertyInfo+data CellRendererAccelAccelModsPropertyInfo+data CellRendererAccelKeycodePropertyInfo+data CellRendererAccelAccelClearedSignalInfo+data CellRendererAccelAccelEditedSignalInfo
+ GI/Gtk/Objects/CellRendererCombo.hs view
@@ -0,0 +1,249 @@++{- |+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.Gtk.Objects.CellRendererCombo+    ( ++-- * Exported types+    CellRendererCombo(..)                   ,+    CellRendererComboK                      ,+    toCellRendererCombo                     ,+    noCellRendererCombo                     ,+++ -- * Methods+-- ** cellRendererComboNew+    cellRendererComboNew                    ,+++++ -- * Properties+-- ** HasEntry+    CellRendererComboHasEntryPropertyInfo   ,+    constructCellRendererComboHasEntry      ,+    getCellRendererComboHasEntry            ,+    setCellRendererComboHasEntry            ,+++-- ** Model+    CellRendererComboModelPropertyInfo      ,+    constructCellRendererComboModel         ,+    getCellRendererComboModel               ,+    setCellRendererComboModel               ,+++-- ** TextColumn+    CellRendererComboTextColumnPropertyInfo ,+    constructCellRendererComboTextColumn    ,+    getCellRendererComboTextColumn          ,+    setCellRendererComboTextColumn          ,+++++ -- * Signals+-- ** Changed+    CellRendererComboChangedCallback        ,+    CellRendererComboChangedCallbackC       ,+    CellRendererComboChangedSignalInfo      ,+    afterCellRendererComboChanged           ,+    cellRendererComboChangedCallbackWrapper ,+    cellRendererComboChangedClosure         ,+    mkCellRendererComboChangedCallback      ,+    noCellRendererComboChangedCallback      ,+    onCellRendererComboChanged              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellRendererCombo = CellRendererCombo (ForeignPtr CellRendererCombo)+foreign import ccall "gtk_cell_renderer_combo_get_type"+    c_gtk_cell_renderer_combo_get_type :: IO GType++type instance ParentTypes CellRendererCombo = CellRendererComboParentTypes+type CellRendererComboParentTypes = '[CellRendererText, CellRenderer, GObject.Object]++instance GObject CellRendererCombo where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_combo_get_type+    ++class GObject o => CellRendererComboK o+instance (GObject o, IsDescendantOf CellRendererCombo o) => CellRendererComboK o++toCellRendererCombo :: CellRendererComboK o => o -> IO CellRendererCombo+toCellRendererCombo = unsafeCastTo CellRendererCombo++noCellRendererCombo :: Maybe CellRendererCombo+noCellRendererCombo = Nothing++-- signal CellRendererCombo::changed+type CellRendererComboChangedCallback =+    T.Text ->+    TreeIter ->+    IO ()++noCellRendererComboChangedCallback :: Maybe CellRendererComboChangedCallback+noCellRendererComboChangedCallback = Nothing++type CellRendererComboChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererComboChangedCallback :: CellRendererComboChangedCallbackC -> IO (FunPtr CellRendererComboChangedCallbackC)++cellRendererComboChangedClosure :: CellRendererComboChangedCallback -> IO Closure+cellRendererComboChangedClosure cb = newCClosure =<< mkCellRendererComboChangedCallback wrapped+    where wrapped = cellRendererComboChangedCallbackWrapper cb++cellRendererComboChangedCallbackWrapper ::+    CellRendererComboChangedCallback ->+    Ptr () ->+    CString ->+    Ptr TreeIter ->+    Ptr () ->+    IO ()+cellRendererComboChangedCallbackWrapper _cb _ path_string new_iter _ = do+    path_string' <- cstringToText path_string+    new_iter' <- (newBoxed TreeIter) new_iter+    _cb  path_string' new_iter'++onCellRendererComboChanged :: (GObject a, MonadIO m) => a -> CellRendererComboChangedCallback -> m SignalHandlerId+onCellRendererComboChanged obj cb = liftIO $ connectCellRendererComboChanged obj cb SignalConnectBefore+afterCellRendererComboChanged :: (GObject a, MonadIO m) => a -> CellRendererComboChangedCallback -> m SignalHandlerId+afterCellRendererComboChanged obj cb = connectCellRendererComboChanged obj cb SignalConnectAfter++connectCellRendererComboChanged :: (GObject a, MonadIO m) =>+                                   a -> CellRendererComboChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererComboChanged obj cb after = liftIO $ do+    cb' <- mkCellRendererComboChangedCallback (cellRendererComboChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- VVV Prop "has-entry"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererComboHasEntry :: (MonadIO m, CellRendererComboK o) => o -> m Bool+getCellRendererComboHasEntry obj = liftIO $ getObjectPropertyBool obj "has-entry"++setCellRendererComboHasEntry :: (MonadIO m, CellRendererComboK o) => o -> Bool -> m ()+setCellRendererComboHasEntry obj val = liftIO $ setObjectPropertyBool obj "has-entry" val++constructCellRendererComboHasEntry :: Bool -> IO ([Char], GValue)+constructCellRendererComboHasEntry val = constructObjectPropertyBool "has-entry" val++data CellRendererComboHasEntryPropertyInfo+instance AttrInfo CellRendererComboHasEntryPropertyInfo where+    type AttrAllowedOps CellRendererComboHasEntryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererComboHasEntryPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererComboHasEntryPropertyInfo = CellRendererComboK+    type AttrGetType CellRendererComboHasEntryPropertyInfo = Bool+    type AttrLabel CellRendererComboHasEntryPropertyInfo = "CellRendererCombo::has-entry"+    attrGet _ = getCellRendererComboHasEntry+    attrSet _ = setCellRendererComboHasEntry+    attrConstruct _ = constructCellRendererComboHasEntry++-- VVV Prop "model"+   -- Type: TInterface "Gtk" "TreeModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererComboModel :: (MonadIO m, CellRendererComboK o) => o -> m TreeModel+getCellRendererComboModel obj = liftIO $ getObjectPropertyObject obj "model" TreeModel++setCellRendererComboModel :: (MonadIO m, CellRendererComboK o, TreeModelK a) => o -> a -> m ()+setCellRendererComboModel obj val = liftIO $ setObjectPropertyObject obj "model" val++constructCellRendererComboModel :: (TreeModelK a) => a -> IO ([Char], GValue)+constructCellRendererComboModel val = constructObjectPropertyObject "model" val++data CellRendererComboModelPropertyInfo+instance AttrInfo CellRendererComboModelPropertyInfo where+    type AttrAllowedOps CellRendererComboModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererComboModelPropertyInfo = TreeModelK+    type AttrBaseTypeConstraint CellRendererComboModelPropertyInfo = CellRendererComboK+    type AttrGetType CellRendererComboModelPropertyInfo = TreeModel+    type AttrLabel CellRendererComboModelPropertyInfo = "CellRendererCombo::model"+    attrGet _ = getCellRendererComboModel+    attrSet _ = setCellRendererComboModel+    attrConstruct _ = constructCellRendererComboModel++-- VVV Prop "text-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererComboTextColumn :: (MonadIO m, CellRendererComboK o) => o -> m Int32+getCellRendererComboTextColumn obj = liftIO $ getObjectPropertyCInt obj "text-column"++setCellRendererComboTextColumn :: (MonadIO m, CellRendererComboK o) => o -> Int32 -> m ()+setCellRendererComboTextColumn obj val = liftIO $ setObjectPropertyCInt obj "text-column" val++constructCellRendererComboTextColumn :: Int32 -> IO ([Char], GValue)+constructCellRendererComboTextColumn val = constructObjectPropertyCInt "text-column" val++data CellRendererComboTextColumnPropertyInfo+instance AttrInfo CellRendererComboTextColumnPropertyInfo where+    type AttrAllowedOps CellRendererComboTextColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererComboTextColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererComboTextColumnPropertyInfo = CellRendererComboK+    type AttrGetType CellRendererComboTextColumnPropertyInfo = Int32+    type AttrLabel CellRendererComboTextColumnPropertyInfo = "CellRendererCombo::text-column"+    attrGet _ = getCellRendererComboTextColumn+    attrSet _ = setCellRendererComboTextColumn+    attrConstruct _ = constructCellRendererComboTextColumn++type instance AttributeList CellRendererCombo = CellRendererComboAttributeList+type CellRendererComboAttributeList = ('[ '("align-set", CellRendererTextAlignSetPropertyInfo), '("alignment", CellRendererTextAlignmentPropertyInfo), '("attributes", CellRendererTextAttributesPropertyInfo), '("background", CellRendererTextBackgroundPropertyInfo), '("background-gdk", CellRendererTextBackgroundGdkPropertyInfo), '("background-rgba", CellRendererTextBackgroundRgbaPropertyInfo), '("background-set", CellRendererTextBackgroundSetPropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editable", CellRendererTextEditablePropertyInfo), '("editable-set", CellRendererTextEditableSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("ellipsize", CellRendererTextEllipsizePropertyInfo), '("ellipsize-set", CellRendererTextEllipsizeSetPropertyInfo), '("family", CellRendererTextFamilyPropertyInfo), '("family-set", CellRendererTextFamilySetPropertyInfo), '("font", CellRendererTextFontPropertyInfo), '("font-desc", CellRendererTextFontDescPropertyInfo), '("foreground", CellRendererTextForegroundPropertyInfo), '("foreground-gdk", CellRendererTextForegroundGdkPropertyInfo), '("foreground-rgba", CellRendererTextForegroundRgbaPropertyInfo), '("foreground-set", CellRendererTextForegroundSetPropertyInfo), '("has-entry", CellRendererComboHasEntryPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("language", CellRendererTextLanguagePropertyInfo), '("language-set", CellRendererTextLanguageSetPropertyInfo), '("markup", CellRendererTextMarkupPropertyInfo), '("max-width-chars", CellRendererTextMaxWidthCharsPropertyInfo), '("mode", CellRendererModePropertyInfo), '("model", CellRendererComboModelPropertyInfo), '("placeholder-text", CellRendererTextPlaceholderTextPropertyInfo), '("rise", CellRendererTextRisePropertyInfo), '("rise-set", CellRendererTextRiseSetPropertyInfo), '("scale", CellRendererTextScalePropertyInfo), '("scale-set", CellRendererTextScaleSetPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("single-paragraph-mode", CellRendererTextSingleParagraphModePropertyInfo), '("size", CellRendererTextSizePropertyInfo), '("size-points", CellRendererTextSizePointsPropertyInfo), '("size-set", CellRendererTextSizeSetPropertyInfo), '("stretch", CellRendererTextStretchPropertyInfo), '("stretch-set", CellRendererTextStretchSetPropertyInfo), '("strikethrough", CellRendererTextStrikethroughPropertyInfo), '("strikethrough-set", CellRendererTextStrikethroughSetPropertyInfo), '("style", CellRendererTextStylePropertyInfo), '("style-set", CellRendererTextStyleSetPropertyInfo), '("text", CellRendererTextTextPropertyInfo), '("text-column", CellRendererComboTextColumnPropertyInfo), '("underline", CellRendererTextUnderlinePropertyInfo), '("underline-set", CellRendererTextUnderlineSetPropertyInfo), '("variant", CellRendererTextVariantPropertyInfo), '("variant-set", CellRendererTextVariantSetPropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("weight", CellRendererTextWeightPropertyInfo), '("weight-set", CellRendererTextWeightSetPropertyInfo), '("width", CellRendererWidthPropertyInfo), '("width-chars", CellRendererTextWidthCharsPropertyInfo), '("wrap-mode", CellRendererTextWrapModePropertyInfo), '("wrap-width", CellRendererTextWrapWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++data CellRendererComboChangedSignalInfo+instance SignalInfo CellRendererComboChangedSignalInfo where+    type HaskellCallbackType CellRendererComboChangedSignalInfo = CellRendererComboChangedCallback+    connectSignal _ = connectCellRendererComboChanged++type instance SignalList CellRendererCombo = CellRendererComboSignalList+type CellRendererComboSignalList = ('[ '("changed", CellRendererComboChangedSignalInfo), '("edited", CellRendererTextEditedSignalInfo), '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererCombo::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererCombo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_combo_new" gtk_cell_renderer_combo_new :: +    IO (Ptr CellRendererCombo)+++cellRendererComboNew ::+    (MonadIO m) =>+    m CellRendererCombo+cellRendererComboNew  = liftIO $ do+    result <- gtk_cell_renderer_combo_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_combo_new" result+    result' <- (newObject CellRendererCombo) result+    return result'++
+ GI/Gtk/Objects/CellRendererCombo.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.CellRendererCombo where++import Prelude ()+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 CellRendererCombo = CellRendererCombo (ForeignPtr CellRendererCombo)+instance GObject CellRendererCombo where+class GObject o => CellRendererComboK o+instance (GObject o, IsDescendantOf CellRendererCombo o) => CellRendererComboK o+data CellRendererComboHasEntryPropertyInfo+data CellRendererComboModelPropertyInfo+data CellRendererComboTextColumnPropertyInfo+data CellRendererComboChangedSignalInfo
+ GI/Gtk/Objects/CellRendererPixbuf.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.Gtk.Objects.CellRendererPixbuf+    ( ++-- * Exported types+    CellRendererPixbuf(..)                  ,+    CellRendererPixbufK                     ,+    toCellRendererPixbuf                    ,+    noCellRendererPixbuf                    ,+++ -- * Methods+-- ** cellRendererPixbufNew+    cellRendererPixbufNew                   ,+++++ -- * Properties+-- ** FollowState+    CellRendererPixbufFollowStatePropertyInfo,+    constructCellRendererPixbufFollowState  ,+    getCellRendererPixbufFollowState        ,+    setCellRendererPixbufFollowState        ,+++-- ** Gicon+    CellRendererPixbufGiconPropertyInfo     ,+    constructCellRendererPixbufGicon        ,+    getCellRendererPixbufGicon              ,+    setCellRendererPixbufGicon              ,+++-- ** IconName+    CellRendererPixbufIconNamePropertyInfo  ,+    constructCellRendererPixbufIconName     ,+    getCellRendererPixbufIconName           ,+    setCellRendererPixbufIconName           ,+++-- ** Pixbuf+    CellRendererPixbufPixbufPropertyInfo    ,+    constructCellRendererPixbufPixbuf       ,+    getCellRendererPixbufPixbuf             ,+    setCellRendererPixbufPixbuf             ,+++-- ** PixbufExpanderClosed+    CellRendererPixbufPixbufExpanderClosedPropertyInfo,+    constructCellRendererPixbufPixbufExpanderClosed,+    getCellRendererPixbufPixbufExpanderClosed,+    setCellRendererPixbufPixbufExpanderClosed,+++-- ** PixbufExpanderOpen+    CellRendererPixbufPixbufExpanderOpenPropertyInfo,+    constructCellRendererPixbufPixbufExpanderOpen,+    getCellRendererPixbufPixbufExpanderOpen ,+    setCellRendererPixbufPixbufExpanderOpen ,+++-- ** StockDetail+    CellRendererPixbufStockDetailPropertyInfo,+    constructCellRendererPixbufStockDetail  ,+    getCellRendererPixbufStockDetail        ,+    setCellRendererPixbufStockDetail        ,+++-- ** StockId+    CellRendererPixbufStockIdPropertyInfo   ,+    constructCellRendererPixbufStockId      ,+    getCellRendererPixbufStockId            ,+    setCellRendererPixbufStockId            ,+++-- ** StockSize+    CellRendererPixbufStockSizePropertyInfo ,+    constructCellRendererPixbufStockSize    ,+    getCellRendererPixbufStockSize          ,+    setCellRendererPixbufStockSize          ,+++-- ** Surface+    CellRendererPixbufSurfacePropertyInfo   ,+    constructCellRendererPixbufSurface      ,+    getCellRendererPixbufSurface            ,+    setCellRendererPixbufSurface            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Cairo as Cairo++newtype CellRendererPixbuf = CellRendererPixbuf (ForeignPtr CellRendererPixbuf)+foreign import ccall "gtk_cell_renderer_pixbuf_get_type"+    c_gtk_cell_renderer_pixbuf_get_type :: IO GType++type instance ParentTypes CellRendererPixbuf = CellRendererPixbufParentTypes+type CellRendererPixbufParentTypes = '[CellRenderer, GObject.Object]++instance GObject CellRendererPixbuf where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_pixbuf_get_type+    ++class GObject o => CellRendererPixbufK o+instance (GObject o, IsDescendantOf CellRendererPixbuf o) => CellRendererPixbufK o++toCellRendererPixbuf :: CellRendererPixbufK o => o -> IO CellRendererPixbuf+toCellRendererPixbuf = unsafeCastTo CellRendererPixbuf++noCellRendererPixbuf :: Maybe CellRendererPixbuf+noCellRendererPixbuf = Nothing++-- VVV Prop "follow-state"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufFollowState :: (MonadIO m, CellRendererPixbufK o) => o -> m Bool+getCellRendererPixbufFollowState obj = liftIO $ getObjectPropertyBool obj "follow-state"++setCellRendererPixbufFollowState :: (MonadIO m, CellRendererPixbufK o) => o -> Bool -> m ()+setCellRendererPixbufFollowState obj val = liftIO $ setObjectPropertyBool obj "follow-state" val++constructCellRendererPixbufFollowState :: Bool -> IO ([Char], GValue)+constructCellRendererPixbufFollowState val = constructObjectPropertyBool "follow-state" val++data CellRendererPixbufFollowStatePropertyInfo+instance AttrInfo CellRendererPixbufFollowStatePropertyInfo where+    type AttrAllowedOps CellRendererPixbufFollowStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufFollowStatePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererPixbufFollowStatePropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufFollowStatePropertyInfo = Bool+    type AttrLabel CellRendererPixbufFollowStatePropertyInfo = "CellRendererPixbuf::follow-state"+    attrGet _ = getCellRendererPixbufFollowState+    attrSet _ = setCellRendererPixbufFollowState+    attrConstruct _ = constructCellRendererPixbufFollowState++-- VVV Prop "gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufGicon :: (MonadIO m, CellRendererPixbufK o) => o -> m Gio.Icon+getCellRendererPixbufGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Gio.Icon++setCellRendererPixbufGicon :: (MonadIO m, CellRendererPixbufK o, Gio.IconK a) => o -> a -> m ()+setCellRendererPixbufGicon obj val = liftIO $ setObjectPropertyObject obj "gicon" val++constructCellRendererPixbufGicon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructCellRendererPixbufGicon val = constructObjectPropertyObject "gicon" val++data CellRendererPixbufGiconPropertyInfo+instance AttrInfo CellRendererPixbufGiconPropertyInfo where+    type AttrAllowedOps CellRendererPixbufGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufGiconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint CellRendererPixbufGiconPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufGiconPropertyInfo = Gio.Icon+    type AttrLabel CellRendererPixbufGiconPropertyInfo = "CellRendererPixbuf::gicon"+    attrGet _ = getCellRendererPixbufGicon+    attrSet _ = setCellRendererPixbufGicon+    attrConstruct _ = constructCellRendererPixbufGicon++-- VVV Prop "icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufIconName :: (MonadIO m, CellRendererPixbufK o) => o -> m T.Text+getCellRendererPixbufIconName obj = liftIO $ getObjectPropertyString obj "icon-name"++setCellRendererPixbufIconName :: (MonadIO m, CellRendererPixbufK o) => o -> T.Text -> m ()+setCellRendererPixbufIconName obj val = liftIO $ setObjectPropertyString obj "icon-name" val++constructCellRendererPixbufIconName :: T.Text -> IO ([Char], GValue)+constructCellRendererPixbufIconName val = constructObjectPropertyString "icon-name" val++data CellRendererPixbufIconNamePropertyInfo+instance AttrInfo CellRendererPixbufIconNamePropertyInfo where+    type AttrAllowedOps CellRendererPixbufIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererPixbufIconNamePropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufIconNamePropertyInfo = T.Text+    type AttrLabel CellRendererPixbufIconNamePropertyInfo = "CellRendererPixbuf::icon-name"+    attrGet _ = getCellRendererPixbufIconName+    attrSet _ = setCellRendererPixbufIconName+    attrConstruct _ = constructCellRendererPixbufIconName++-- VVV Prop "pixbuf"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufPixbuf :: (MonadIO m, CellRendererPixbufK o) => o -> m GdkPixbuf.Pixbuf+getCellRendererPixbufPixbuf obj = liftIO $ getObjectPropertyObject obj "pixbuf" GdkPixbuf.Pixbuf++setCellRendererPixbufPixbuf :: (MonadIO m, CellRendererPixbufK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setCellRendererPixbufPixbuf obj val = liftIO $ setObjectPropertyObject obj "pixbuf" val++constructCellRendererPixbufPixbuf :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructCellRendererPixbufPixbuf val = constructObjectPropertyObject "pixbuf" val++data CellRendererPixbufPixbufPropertyInfo+instance AttrInfo CellRendererPixbufPixbufPropertyInfo where+    type AttrAllowedOps CellRendererPixbufPixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufPixbufPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint CellRendererPixbufPixbufPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufPixbufPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel CellRendererPixbufPixbufPropertyInfo = "CellRendererPixbuf::pixbuf"+    attrGet _ = getCellRendererPixbufPixbuf+    attrSet _ = setCellRendererPixbufPixbuf+    attrConstruct _ = constructCellRendererPixbufPixbuf++-- VVV Prop "pixbuf-expander-closed"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, CellRendererPixbufK o) => o -> m GdkPixbuf.Pixbuf+getCellRendererPixbufPixbufExpanderClosed obj = liftIO $ getObjectPropertyObject obj "pixbuf-expander-closed" GdkPixbuf.Pixbuf++setCellRendererPixbufPixbufExpanderClosed :: (MonadIO m, CellRendererPixbufK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setCellRendererPixbufPixbufExpanderClosed obj val = liftIO $ setObjectPropertyObject obj "pixbuf-expander-closed" val++constructCellRendererPixbufPixbufExpanderClosed :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructCellRendererPixbufPixbufExpanderClosed val = constructObjectPropertyObject "pixbuf-expander-closed" val++data CellRendererPixbufPixbufExpanderClosedPropertyInfo+instance AttrInfo CellRendererPixbufPixbufExpanderClosedPropertyInfo where+    type AttrAllowedOps CellRendererPixbufPixbufExpanderClosedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufPixbufExpanderClosedPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint CellRendererPixbufPixbufExpanderClosedPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufPixbufExpanderClosedPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel CellRendererPixbufPixbufExpanderClosedPropertyInfo = "CellRendererPixbuf::pixbuf-expander-closed"+    attrGet _ = getCellRendererPixbufPixbufExpanderClosed+    attrSet _ = setCellRendererPixbufPixbufExpanderClosed+    attrConstruct _ = constructCellRendererPixbufPixbufExpanderClosed++-- VVV Prop "pixbuf-expander-open"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, CellRendererPixbufK o) => o -> m GdkPixbuf.Pixbuf+getCellRendererPixbufPixbufExpanderOpen obj = liftIO $ getObjectPropertyObject obj "pixbuf-expander-open" GdkPixbuf.Pixbuf++setCellRendererPixbufPixbufExpanderOpen :: (MonadIO m, CellRendererPixbufK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setCellRendererPixbufPixbufExpanderOpen obj val = liftIO $ setObjectPropertyObject obj "pixbuf-expander-open" val++constructCellRendererPixbufPixbufExpanderOpen :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructCellRendererPixbufPixbufExpanderOpen val = constructObjectPropertyObject "pixbuf-expander-open" val++data CellRendererPixbufPixbufExpanderOpenPropertyInfo+instance AttrInfo CellRendererPixbufPixbufExpanderOpenPropertyInfo where+    type AttrAllowedOps CellRendererPixbufPixbufExpanderOpenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufPixbufExpanderOpenPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint CellRendererPixbufPixbufExpanderOpenPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufPixbufExpanderOpenPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel CellRendererPixbufPixbufExpanderOpenPropertyInfo = "CellRendererPixbuf::pixbuf-expander-open"+    attrGet _ = getCellRendererPixbufPixbufExpanderOpen+    attrSet _ = setCellRendererPixbufPixbufExpanderOpen+    attrConstruct _ = constructCellRendererPixbufPixbufExpanderOpen++-- VVV Prop "stock-detail"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufStockDetail :: (MonadIO m, CellRendererPixbufK o) => o -> m T.Text+getCellRendererPixbufStockDetail obj = liftIO $ getObjectPropertyString obj "stock-detail"++setCellRendererPixbufStockDetail :: (MonadIO m, CellRendererPixbufK o) => o -> T.Text -> m ()+setCellRendererPixbufStockDetail obj val = liftIO $ setObjectPropertyString obj "stock-detail" val++constructCellRendererPixbufStockDetail :: T.Text -> IO ([Char], GValue)+constructCellRendererPixbufStockDetail val = constructObjectPropertyString "stock-detail" val++data CellRendererPixbufStockDetailPropertyInfo+instance AttrInfo CellRendererPixbufStockDetailPropertyInfo where+    type AttrAllowedOps CellRendererPixbufStockDetailPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufStockDetailPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererPixbufStockDetailPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufStockDetailPropertyInfo = T.Text+    type AttrLabel CellRendererPixbufStockDetailPropertyInfo = "CellRendererPixbuf::stock-detail"+    attrGet _ = getCellRendererPixbufStockDetail+    attrSet _ = setCellRendererPixbufStockDetail+    attrConstruct _ = constructCellRendererPixbufStockDetail++-- VVV Prop "stock-id"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufStockId :: (MonadIO m, CellRendererPixbufK o) => o -> m T.Text+getCellRendererPixbufStockId obj = liftIO $ getObjectPropertyString obj "stock-id"++setCellRendererPixbufStockId :: (MonadIO m, CellRendererPixbufK o) => o -> T.Text -> m ()+setCellRendererPixbufStockId obj val = liftIO $ setObjectPropertyString obj "stock-id" val++constructCellRendererPixbufStockId :: T.Text -> IO ([Char], GValue)+constructCellRendererPixbufStockId val = constructObjectPropertyString "stock-id" val++data CellRendererPixbufStockIdPropertyInfo+instance AttrInfo CellRendererPixbufStockIdPropertyInfo where+    type AttrAllowedOps CellRendererPixbufStockIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufStockIdPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererPixbufStockIdPropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufStockIdPropertyInfo = T.Text+    type AttrLabel CellRendererPixbufStockIdPropertyInfo = "CellRendererPixbuf::stock-id"+    attrGet _ = getCellRendererPixbufStockId+    attrSet _ = setCellRendererPixbufStockId+    attrConstruct _ = constructCellRendererPixbufStockId++-- VVV Prop "stock-size"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufStockSize :: (MonadIO m, CellRendererPixbufK o) => o -> m Word32+getCellRendererPixbufStockSize obj = liftIO $ getObjectPropertyCUInt obj "stock-size"++setCellRendererPixbufStockSize :: (MonadIO m, CellRendererPixbufK o) => o -> Word32 -> m ()+setCellRendererPixbufStockSize obj val = liftIO $ setObjectPropertyCUInt obj "stock-size" val++constructCellRendererPixbufStockSize :: Word32 -> IO ([Char], GValue)+constructCellRendererPixbufStockSize val = constructObjectPropertyCUInt "stock-size" val++data CellRendererPixbufStockSizePropertyInfo+instance AttrInfo CellRendererPixbufStockSizePropertyInfo where+    type AttrAllowedOps CellRendererPixbufStockSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufStockSizePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererPixbufStockSizePropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufStockSizePropertyInfo = Word32+    type AttrLabel CellRendererPixbufStockSizePropertyInfo = "CellRendererPixbuf::stock-size"+    attrGet _ = getCellRendererPixbufStockSize+    attrSet _ = setCellRendererPixbufStockSize+    attrConstruct _ = constructCellRendererPixbufStockSize++-- VVV Prop "surface"+   -- Type: TInterface "cairo" "Surface"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererPixbufSurface :: (MonadIO m, CellRendererPixbufK o) => o -> m Cairo.Surface+getCellRendererPixbufSurface obj = liftIO $ getObjectPropertyBoxed obj "surface" Cairo.Surface++setCellRendererPixbufSurface :: (MonadIO m, CellRendererPixbufK o) => o -> Cairo.Surface -> m ()+setCellRendererPixbufSurface obj val = liftIO $ setObjectPropertyBoxed obj "surface" val++constructCellRendererPixbufSurface :: Cairo.Surface -> IO ([Char], GValue)+constructCellRendererPixbufSurface val = constructObjectPropertyBoxed "surface" val++data CellRendererPixbufSurfacePropertyInfo+instance AttrInfo CellRendererPixbufSurfacePropertyInfo where+    type AttrAllowedOps CellRendererPixbufSurfacePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererPixbufSurfacePropertyInfo = (~) Cairo.Surface+    type AttrBaseTypeConstraint CellRendererPixbufSurfacePropertyInfo = CellRendererPixbufK+    type AttrGetType CellRendererPixbufSurfacePropertyInfo = Cairo.Surface+    type AttrLabel CellRendererPixbufSurfacePropertyInfo = "CellRendererPixbuf::surface"+    attrGet _ = getCellRendererPixbufSurface+    attrSet _ = setCellRendererPixbufSurface+    attrConstruct _ = constructCellRendererPixbufSurface++type instance AttributeList CellRendererPixbuf = CellRendererPixbufAttributeList+type CellRendererPixbufAttributeList = ('[ '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("follow-state", CellRendererPixbufFollowStatePropertyInfo), '("gicon", CellRendererPixbufGiconPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("icon-name", CellRendererPixbufIconNamePropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("pixbuf", CellRendererPixbufPixbufPropertyInfo), '("pixbuf-expander-closed", CellRendererPixbufPixbufExpanderClosedPropertyInfo), '("pixbuf-expander-open", CellRendererPixbufPixbufExpanderOpenPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("stock-detail", CellRendererPixbufStockDetailPropertyInfo), '("stock-id", CellRendererPixbufStockIdPropertyInfo), '("stock-size", CellRendererPixbufStockSizePropertyInfo), '("surface", CellRendererPixbufSurfacePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellRendererPixbuf = CellRendererPixbufSignalList+type CellRendererPixbufSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererPixbuf::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererPixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_pixbuf_new" gtk_cell_renderer_pixbuf_new :: +    IO (Ptr CellRendererPixbuf)+++cellRendererPixbufNew ::+    (MonadIO m) =>+    m CellRendererPixbuf+cellRendererPixbufNew  = liftIO $ do+    result <- gtk_cell_renderer_pixbuf_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_pixbuf_new" result+    result' <- (newObject CellRendererPixbuf) result+    return result'++
+ GI/Gtk/Objects/CellRendererPixbuf.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gtk.Objects.CellRendererPixbuf where++import Prelude ()+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 CellRendererPixbuf = CellRendererPixbuf (ForeignPtr CellRendererPixbuf)+instance GObject CellRendererPixbuf where+class GObject o => CellRendererPixbufK o+instance (GObject o, IsDescendantOf CellRendererPixbuf o) => CellRendererPixbufK o+data CellRendererPixbufFollowStatePropertyInfo+data CellRendererPixbufGiconPropertyInfo+data CellRendererPixbufIconNamePropertyInfo+data CellRendererPixbufPixbufPropertyInfo+data CellRendererPixbufPixbufExpanderClosedPropertyInfo+data CellRendererPixbufPixbufExpanderOpenPropertyInfo+data CellRendererPixbufStockDetailPropertyInfo+data CellRendererPixbufStockIdPropertyInfo+data CellRendererPixbufStockSizePropertyInfo+data CellRendererPixbufSurfacePropertyInfo
+ GI/Gtk/Objects/CellRendererProgress.hs view
@@ -0,0 +1,276 @@++{- |+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.Gtk.Objects.CellRendererProgress+    ( ++-- * Exported types+    CellRendererProgress(..)                ,+    CellRendererProgressK                   ,+    toCellRendererProgress                  ,+    noCellRendererProgress                  ,+++ -- * Methods+-- ** cellRendererProgressNew+    cellRendererProgressNew                 ,+++++ -- * Properties+-- ** Inverted+    CellRendererProgressInvertedPropertyInfo,+    constructCellRendererProgressInverted   ,+    getCellRendererProgressInverted         ,+    setCellRendererProgressInverted         ,+++-- ** Pulse+    CellRendererProgressPulsePropertyInfo   ,+    constructCellRendererProgressPulse      ,+    getCellRendererProgressPulse            ,+    setCellRendererProgressPulse            ,+++-- ** Text+    CellRendererProgressTextPropertyInfo    ,+    constructCellRendererProgressText       ,+    getCellRendererProgressText             ,+    setCellRendererProgressText             ,+++-- ** TextXalign+    CellRendererProgressTextXalignPropertyInfo,+    constructCellRendererProgressTextXalign ,+    getCellRendererProgressTextXalign       ,+    setCellRendererProgressTextXalign       ,+++-- ** TextYalign+    CellRendererProgressTextYalignPropertyInfo,+    constructCellRendererProgressTextYalign ,+    getCellRendererProgressTextYalign       ,+    setCellRendererProgressTextYalign       ,+++-- ** Value+    CellRendererProgressValuePropertyInfo   ,+    constructCellRendererProgressValue      ,+    getCellRendererProgressValue            ,+    setCellRendererProgressValue            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellRendererProgress = CellRendererProgress (ForeignPtr CellRendererProgress)+foreign import ccall "gtk_cell_renderer_progress_get_type"+    c_gtk_cell_renderer_progress_get_type :: IO GType++type instance ParentTypes CellRendererProgress = CellRendererProgressParentTypes+type CellRendererProgressParentTypes = '[CellRenderer, GObject.Object, Orientable]++instance GObject CellRendererProgress where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_progress_get_type+    ++class GObject o => CellRendererProgressK o+instance (GObject o, IsDescendantOf CellRendererProgress o) => CellRendererProgressK o++toCellRendererProgress :: CellRendererProgressK o => o -> IO CellRendererProgress+toCellRendererProgress = unsafeCastTo CellRendererProgress++noCellRendererProgress :: Maybe CellRendererProgress+noCellRendererProgress = Nothing++-- VVV Prop "inverted"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressInverted :: (MonadIO m, CellRendererProgressK o) => o -> m Bool+getCellRendererProgressInverted obj = liftIO $ getObjectPropertyBool obj "inverted"++setCellRendererProgressInverted :: (MonadIO m, CellRendererProgressK o) => o -> Bool -> m ()+setCellRendererProgressInverted obj val = liftIO $ setObjectPropertyBool obj "inverted" val++constructCellRendererProgressInverted :: Bool -> IO ([Char], GValue)+constructCellRendererProgressInverted val = constructObjectPropertyBool "inverted" val++data CellRendererProgressInvertedPropertyInfo+instance AttrInfo CellRendererProgressInvertedPropertyInfo where+    type AttrAllowedOps CellRendererProgressInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressInvertedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererProgressInvertedPropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressInvertedPropertyInfo = Bool+    type AttrLabel CellRendererProgressInvertedPropertyInfo = "CellRendererProgress::inverted"+    attrGet _ = getCellRendererProgressInverted+    attrSet _ = setCellRendererProgressInverted+    attrConstruct _ = constructCellRendererProgressInverted++-- VVV Prop "pulse"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressPulse :: (MonadIO m, CellRendererProgressK o) => o -> m Int32+getCellRendererProgressPulse obj = liftIO $ getObjectPropertyCInt obj "pulse"++setCellRendererProgressPulse :: (MonadIO m, CellRendererProgressK o) => o -> Int32 -> m ()+setCellRendererProgressPulse obj val = liftIO $ setObjectPropertyCInt obj "pulse" val++constructCellRendererProgressPulse :: Int32 -> IO ([Char], GValue)+constructCellRendererProgressPulse val = constructObjectPropertyCInt "pulse" val++data CellRendererProgressPulsePropertyInfo+instance AttrInfo CellRendererProgressPulsePropertyInfo where+    type AttrAllowedOps CellRendererProgressPulsePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressPulsePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererProgressPulsePropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressPulsePropertyInfo = Int32+    type AttrLabel CellRendererProgressPulsePropertyInfo = "CellRendererProgress::pulse"+    attrGet _ = getCellRendererProgressPulse+    attrSet _ = setCellRendererProgressPulse+    attrConstruct _ = constructCellRendererProgressPulse++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressText :: (MonadIO m, CellRendererProgressK o) => o -> m T.Text+getCellRendererProgressText obj = liftIO $ getObjectPropertyString obj "text"++setCellRendererProgressText :: (MonadIO m, CellRendererProgressK o) => o -> T.Text -> m ()+setCellRendererProgressText obj val = liftIO $ setObjectPropertyString obj "text" val++constructCellRendererProgressText :: T.Text -> IO ([Char], GValue)+constructCellRendererProgressText val = constructObjectPropertyString "text" val++data CellRendererProgressTextPropertyInfo+instance AttrInfo CellRendererProgressTextPropertyInfo where+    type AttrAllowedOps CellRendererProgressTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererProgressTextPropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressTextPropertyInfo = T.Text+    type AttrLabel CellRendererProgressTextPropertyInfo = "CellRendererProgress::text"+    attrGet _ = getCellRendererProgressText+    attrSet _ = setCellRendererProgressText+    attrConstruct _ = constructCellRendererProgressText++-- VVV Prop "text-xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressTextXalign :: (MonadIO m, CellRendererProgressK o) => o -> m Float+getCellRendererProgressTextXalign obj = liftIO $ getObjectPropertyFloat obj "text-xalign"++setCellRendererProgressTextXalign :: (MonadIO m, CellRendererProgressK o) => o -> Float -> m ()+setCellRendererProgressTextXalign obj val = liftIO $ setObjectPropertyFloat obj "text-xalign" val++constructCellRendererProgressTextXalign :: Float -> IO ([Char], GValue)+constructCellRendererProgressTextXalign val = constructObjectPropertyFloat "text-xalign" val++data CellRendererProgressTextXalignPropertyInfo+instance AttrInfo CellRendererProgressTextXalignPropertyInfo where+    type AttrAllowedOps CellRendererProgressTextXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressTextXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint CellRendererProgressTextXalignPropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressTextXalignPropertyInfo = Float+    type AttrLabel CellRendererProgressTextXalignPropertyInfo = "CellRendererProgress::text-xalign"+    attrGet _ = getCellRendererProgressTextXalign+    attrSet _ = setCellRendererProgressTextXalign+    attrConstruct _ = constructCellRendererProgressTextXalign++-- VVV Prop "text-yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressTextYalign :: (MonadIO m, CellRendererProgressK o) => o -> m Float+getCellRendererProgressTextYalign obj = liftIO $ getObjectPropertyFloat obj "text-yalign"++setCellRendererProgressTextYalign :: (MonadIO m, CellRendererProgressK o) => o -> Float -> m ()+setCellRendererProgressTextYalign obj val = liftIO $ setObjectPropertyFloat obj "text-yalign" val++constructCellRendererProgressTextYalign :: Float -> IO ([Char], GValue)+constructCellRendererProgressTextYalign val = constructObjectPropertyFloat "text-yalign" val++data CellRendererProgressTextYalignPropertyInfo+instance AttrInfo CellRendererProgressTextYalignPropertyInfo where+    type AttrAllowedOps CellRendererProgressTextYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressTextYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint CellRendererProgressTextYalignPropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressTextYalignPropertyInfo = Float+    type AttrLabel CellRendererProgressTextYalignPropertyInfo = "CellRendererProgress::text-yalign"+    attrGet _ = getCellRendererProgressTextYalign+    attrSet _ = setCellRendererProgressTextYalign+    attrConstruct _ = constructCellRendererProgressTextYalign++-- VVV Prop "value"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererProgressValue :: (MonadIO m, CellRendererProgressK o) => o -> m Int32+getCellRendererProgressValue obj = liftIO $ getObjectPropertyCInt obj "value"++setCellRendererProgressValue :: (MonadIO m, CellRendererProgressK o) => o -> Int32 -> m ()+setCellRendererProgressValue obj val = liftIO $ setObjectPropertyCInt obj "value" val++constructCellRendererProgressValue :: Int32 -> IO ([Char], GValue)+constructCellRendererProgressValue val = constructObjectPropertyCInt "value" val++data CellRendererProgressValuePropertyInfo+instance AttrInfo CellRendererProgressValuePropertyInfo where+    type AttrAllowedOps CellRendererProgressValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererProgressValuePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererProgressValuePropertyInfo = CellRendererProgressK+    type AttrGetType CellRendererProgressValuePropertyInfo = Int32+    type AttrLabel CellRendererProgressValuePropertyInfo = "CellRendererProgress::value"+    attrGet _ = getCellRendererProgressValue+    attrSet _ = setCellRendererProgressValue+    attrConstruct _ = constructCellRendererProgressValue++type instance AttributeList CellRendererProgress = CellRendererProgressAttributeList+type CellRendererProgressAttributeList = ('[ '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("inverted", CellRendererProgressInvertedPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("pulse", CellRendererProgressPulsePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("text", CellRendererProgressTextPropertyInfo), '("text-xalign", CellRendererProgressTextXalignPropertyInfo), '("text-yalign", CellRendererProgressTextYalignPropertyInfo), '("value", CellRendererProgressValuePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellRendererProgress = CellRendererProgressSignalList+type CellRendererProgressSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererProgress::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererProgress"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_progress_new" gtk_cell_renderer_progress_new :: +    IO (Ptr CellRendererProgress)+++cellRendererProgressNew ::+    (MonadIO m) =>+    m CellRendererProgress+cellRendererProgressNew  = liftIO $ do+    result <- gtk_cell_renderer_progress_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_progress_new" result+    result' <- (newObject CellRendererProgress) result+    return result'++
+ GI/Gtk/Objects/CellRendererProgress.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.CellRendererProgress where++import Prelude ()+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 CellRendererProgress = CellRendererProgress (ForeignPtr CellRendererProgress)+instance GObject CellRendererProgress where+class GObject o => CellRendererProgressK o+instance (GObject o, IsDescendantOf CellRendererProgress o) => CellRendererProgressK o+data CellRendererProgressInvertedPropertyInfo+data CellRendererProgressPulsePropertyInfo+data CellRendererProgressTextPropertyInfo+data CellRendererProgressTextXalignPropertyInfo+data CellRendererProgressTextYalignPropertyInfo+data CellRendererProgressValuePropertyInfo
+ GI/Gtk/Objects/CellRendererSpin.hs view
@@ -0,0 +1,183 @@++{- |+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.Gtk.Objects.CellRendererSpin+    ( ++-- * Exported types+    CellRendererSpin(..)                    ,+    CellRendererSpinK                       ,+    toCellRendererSpin                      ,+    noCellRendererSpin                      ,+++ -- * Methods+-- ** cellRendererSpinNew+    cellRendererSpinNew                     ,+++++ -- * Properties+-- ** Adjustment+    CellRendererSpinAdjustmentPropertyInfo  ,+    constructCellRendererSpinAdjustment     ,+    getCellRendererSpinAdjustment           ,+    setCellRendererSpinAdjustment           ,+++-- ** ClimbRate+    CellRendererSpinClimbRatePropertyInfo   ,+    constructCellRendererSpinClimbRate      ,+    getCellRendererSpinClimbRate            ,+    setCellRendererSpinClimbRate            ,+++-- ** Digits+    CellRendererSpinDigitsPropertyInfo      ,+    constructCellRendererSpinDigits         ,+    getCellRendererSpinDigits               ,+    setCellRendererSpinDigits               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellRendererSpin = CellRendererSpin (ForeignPtr CellRendererSpin)+foreign import ccall "gtk_cell_renderer_spin_get_type"+    c_gtk_cell_renderer_spin_get_type :: IO GType++type instance ParentTypes CellRendererSpin = CellRendererSpinParentTypes+type CellRendererSpinParentTypes = '[CellRendererText, CellRenderer, GObject.Object]++instance GObject CellRendererSpin where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_spin_get_type+    ++class GObject o => CellRendererSpinK o+instance (GObject o, IsDescendantOf CellRendererSpin o) => CellRendererSpinK o++toCellRendererSpin :: CellRendererSpinK o => o -> IO CellRendererSpin+toCellRendererSpin = unsafeCastTo CellRendererSpin++noCellRendererSpin :: Maybe CellRendererSpin+noCellRendererSpin = Nothing++-- VVV Prop "adjustment"+   -- Type: TInterface "Gtk" "Adjustment"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinAdjustment :: (MonadIO m, CellRendererSpinK o) => o -> m Adjustment+getCellRendererSpinAdjustment obj = liftIO $ getObjectPropertyObject obj "adjustment" Adjustment++setCellRendererSpinAdjustment :: (MonadIO m, CellRendererSpinK o, AdjustmentK a) => o -> a -> m ()+setCellRendererSpinAdjustment obj val = liftIO $ setObjectPropertyObject obj "adjustment" val++constructCellRendererSpinAdjustment :: (AdjustmentK a) => a -> IO ([Char], GValue)+constructCellRendererSpinAdjustment val = constructObjectPropertyObject "adjustment" val++data CellRendererSpinAdjustmentPropertyInfo+instance AttrInfo CellRendererSpinAdjustmentPropertyInfo where+    type AttrAllowedOps CellRendererSpinAdjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinAdjustmentPropertyInfo = AdjustmentK+    type AttrBaseTypeConstraint CellRendererSpinAdjustmentPropertyInfo = CellRendererSpinK+    type AttrGetType CellRendererSpinAdjustmentPropertyInfo = Adjustment+    type AttrLabel CellRendererSpinAdjustmentPropertyInfo = "CellRendererSpin::adjustment"+    attrGet _ = getCellRendererSpinAdjustment+    attrSet _ = setCellRendererSpinAdjustment+    attrConstruct _ = constructCellRendererSpinAdjustment++-- VVV Prop "climb-rate"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinClimbRate :: (MonadIO m, CellRendererSpinK o) => o -> m Double+getCellRendererSpinClimbRate obj = liftIO $ getObjectPropertyDouble obj "climb-rate"++setCellRendererSpinClimbRate :: (MonadIO m, CellRendererSpinK o) => o -> Double -> m ()+setCellRendererSpinClimbRate obj val = liftIO $ setObjectPropertyDouble obj "climb-rate" val++constructCellRendererSpinClimbRate :: Double -> IO ([Char], GValue)+constructCellRendererSpinClimbRate val = constructObjectPropertyDouble "climb-rate" val++data CellRendererSpinClimbRatePropertyInfo+instance AttrInfo CellRendererSpinClimbRatePropertyInfo where+    type AttrAllowedOps CellRendererSpinClimbRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinClimbRatePropertyInfo = (~) Double+    type AttrBaseTypeConstraint CellRendererSpinClimbRatePropertyInfo = CellRendererSpinK+    type AttrGetType CellRendererSpinClimbRatePropertyInfo = Double+    type AttrLabel CellRendererSpinClimbRatePropertyInfo = "CellRendererSpin::climb-rate"+    attrGet _ = getCellRendererSpinClimbRate+    attrSet _ = setCellRendererSpinClimbRate+    attrConstruct _ = constructCellRendererSpinClimbRate++-- VVV Prop "digits"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinDigits :: (MonadIO m, CellRendererSpinK o) => o -> m Word32+getCellRendererSpinDigits obj = liftIO $ getObjectPropertyCUInt obj "digits"++setCellRendererSpinDigits :: (MonadIO m, CellRendererSpinK o) => o -> Word32 -> m ()+setCellRendererSpinDigits obj val = liftIO $ setObjectPropertyCUInt obj "digits" val++constructCellRendererSpinDigits :: Word32 -> IO ([Char], GValue)+constructCellRendererSpinDigits val = constructObjectPropertyCUInt "digits" val++data CellRendererSpinDigitsPropertyInfo+instance AttrInfo CellRendererSpinDigitsPropertyInfo where+    type AttrAllowedOps CellRendererSpinDigitsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinDigitsPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererSpinDigitsPropertyInfo = CellRendererSpinK+    type AttrGetType CellRendererSpinDigitsPropertyInfo = Word32+    type AttrLabel CellRendererSpinDigitsPropertyInfo = "CellRendererSpin::digits"+    attrGet _ = getCellRendererSpinDigits+    attrSet _ = setCellRendererSpinDigits+    attrConstruct _ = constructCellRendererSpinDigits++type instance AttributeList CellRendererSpin = CellRendererSpinAttributeList+type CellRendererSpinAttributeList = ('[ '("adjustment", CellRendererSpinAdjustmentPropertyInfo), '("align-set", CellRendererTextAlignSetPropertyInfo), '("alignment", CellRendererTextAlignmentPropertyInfo), '("attributes", CellRendererTextAttributesPropertyInfo), '("background", CellRendererTextBackgroundPropertyInfo), '("background-gdk", CellRendererTextBackgroundGdkPropertyInfo), '("background-rgba", CellRendererTextBackgroundRgbaPropertyInfo), '("background-set", CellRendererTextBackgroundSetPropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("climb-rate", CellRendererSpinClimbRatePropertyInfo), '("digits", CellRendererSpinDigitsPropertyInfo), '("editable", CellRendererTextEditablePropertyInfo), '("editable-set", CellRendererTextEditableSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("ellipsize", CellRendererTextEllipsizePropertyInfo), '("ellipsize-set", CellRendererTextEllipsizeSetPropertyInfo), '("family", CellRendererTextFamilyPropertyInfo), '("family-set", CellRendererTextFamilySetPropertyInfo), '("font", CellRendererTextFontPropertyInfo), '("font-desc", CellRendererTextFontDescPropertyInfo), '("foreground", CellRendererTextForegroundPropertyInfo), '("foreground-gdk", CellRendererTextForegroundGdkPropertyInfo), '("foreground-rgba", CellRendererTextForegroundRgbaPropertyInfo), '("foreground-set", CellRendererTextForegroundSetPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("language", CellRendererTextLanguagePropertyInfo), '("language-set", CellRendererTextLanguageSetPropertyInfo), '("markup", CellRendererTextMarkupPropertyInfo), '("max-width-chars", CellRendererTextMaxWidthCharsPropertyInfo), '("mode", CellRendererModePropertyInfo), '("placeholder-text", CellRendererTextPlaceholderTextPropertyInfo), '("rise", CellRendererTextRisePropertyInfo), '("rise-set", CellRendererTextRiseSetPropertyInfo), '("scale", CellRendererTextScalePropertyInfo), '("scale-set", CellRendererTextScaleSetPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("single-paragraph-mode", CellRendererTextSingleParagraphModePropertyInfo), '("size", CellRendererTextSizePropertyInfo), '("size-points", CellRendererTextSizePointsPropertyInfo), '("size-set", CellRendererTextSizeSetPropertyInfo), '("stretch", CellRendererTextStretchPropertyInfo), '("stretch-set", CellRendererTextStretchSetPropertyInfo), '("strikethrough", CellRendererTextStrikethroughPropertyInfo), '("strikethrough-set", CellRendererTextStrikethroughSetPropertyInfo), '("style", CellRendererTextStylePropertyInfo), '("style-set", CellRendererTextStyleSetPropertyInfo), '("text", CellRendererTextTextPropertyInfo), '("underline", CellRendererTextUnderlinePropertyInfo), '("underline-set", CellRendererTextUnderlineSetPropertyInfo), '("variant", CellRendererTextVariantPropertyInfo), '("variant-set", CellRendererTextVariantSetPropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("weight", CellRendererTextWeightPropertyInfo), '("weight-set", CellRendererTextWeightSetPropertyInfo), '("width", CellRendererWidthPropertyInfo), '("width-chars", CellRendererTextWidthCharsPropertyInfo), '("wrap-mode", CellRendererTextWrapModePropertyInfo), '("wrap-width", CellRendererTextWrapWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellRendererSpin = CellRendererSpinSignalList+type CellRendererSpinSignalList = ('[ '("edited", CellRendererTextEditedSignalInfo), '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererSpin::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererSpin"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_spin_new" gtk_cell_renderer_spin_new :: +    IO (Ptr CellRendererSpin)+++cellRendererSpinNew ::+    (MonadIO m) =>+    m CellRendererSpin+cellRendererSpinNew  = liftIO $ do+    result <- gtk_cell_renderer_spin_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_spin_new" result+    result' <- (newObject CellRendererSpin) result+    return result'++
+ GI/Gtk/Objects/CellRendererSpin.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.CellRendererSpin where++import Prelude ()+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 CellRendererSpin = CellRendererSpin (ForeignPtr CellRendererSpin)+instance GObject CellRendererSpin where+class GObject o => CellRendererSpinK o+instance (GObject o, IsDescendantOf CellRendererSpin o) => CellRendererSpinK o+data CellRendererSpinAdjustmentPropertyInfo+data CellRendererSpinClimbRatePropertyInfo+data CellRendererSpinDigitsPropertyInfo
+ GI/Gtk/Objects/CellRendererSpinner.hs view
@@ -0,0 +1,183 @@++{- |+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.Gtk.Objects.CellRendererSpinner+    ( ++-- * Exported types+    CellRendererSpinner(..)                 ,+    CellRendererSpinnerK                    ,+    toCellRendererSpinner                   ,+    noCellRendererSpinner                   ,+++ -- * Methods+-- ** cellRendererSpinnerNew+    cellRendererSpinnerNew                  ,+++++ -- * Properties+-- ** Active+    CellRendererSpinnerActivePropertyInfo   ,+    constructCellRendererSpinnerActive      ,+    getCellRendererSpinnerActive            ,+    setCellRendererSpinnerActive            ,+++-- ** Pulse+    CellRendererSpinnerPulsePropertyInfo    ,+    constructCellRendererSpinnerPulse       ,+    getCellRendererSpinnerPulse             ,+    setCellRendererSpinnerPulse             ,+++-- ** Size+    CellRendererSpinnerSizePropertyInfo     ,+    constructCellRendererSpinnerSize        ,+    getCellRendererSpinnerSize              ,+    setCellRendererSpinnerSize              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellRendererSpinner = CellRendererSpinner (ForeignPtr CellRendererSpinner)+foreign import ccall "gtk_cell_renderer_spinner_get_type"+    c_gtk_cell_renderer_spinner_get_type :: IO GType++type instance ParentTypes CellRendererSpinner = CellRendererSpinnerParentTypes+type CellRendererSpinnerParentTypes = '[CellRenderer, GObject.Object]++instance GObject CellRendererSpinner where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_spinner_get_type+    ++class GObject o => CellRendererSpinnerK o+instance (GObject o, IsDescendantOf CellRendererSpinner o) => CellRendererSpinnerK o++toCellRendererSpinner :: CellRendererSpinnerK o => o -> IO CellRendererSpinner+toCellRendererSpinner = unsafeCastTo CellRendererSpinner++noCellRendererSpinner :: Maybe CellRendererSpinner+noCellRendererSpinner = Nothing++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinnerActive :: (MonadIO m, CellRendererSpinnerK o) => o -> m Bool+getCellRendererSpinnerActive obj = liftIO $ getObjectPropertyBool obj "active"++setCellRendererSpinnerActive :: (MonadIO m, CellRendererSpinnerK o) => o -> Bool -> m ()+setCellRendererSpinnerActive obj val = liftIO $ setObjectPropertyBool obj "active" val++constructCellRendererSpinnerActive :: Bool -> IO ([Char], GValue)+constructCellRendererSpinnerActive val = constructObjectPropertyBool "active" val++data CellRendererSpinnerActivePropertyInfo+instance AttrInfo CellRendererSpinnerActivePropertyInfo where+    type AttrAllowedOps CellRendererSpinnerActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinnerActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererSpinnerActivePropertyInfo = CellRendererSpinnerK+    type AttrGetType CellRendererSpinnerActivePropertyInfo = Bool+    type AttrLabel CellRendererSpinnerActivePropertyInfo = "CellRendererSpinner::active"+    attrGet _ = getCellRendererSpinnerActive+    attrSet _ = setCellRendererSpinnerActive+    attrConstruct _ = constructCellRendererSpinnerActive++-- VVV Prop "pulse"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinnerPulse :: (MonadIO m, CellRendererSpinnerK o) => o -> m Word32+getCellRendererSpinnerPulse obj = liftIO $ getObjectPropertyCUInt obj "pulse"++setCellRendererSpinnerPulse :: (MonadIO m, CellRendererSpinnerK o) => o -> Word32 -> m ()+setCellRendererSpinnerPulse obj val = liftIO $ setObjectPropertyCUInt obj "pulse" val++constructCellRendererSpinnerPulse :: Word32 -> IO ([Char], GValue)+constructCellRendererSpinnerPulse val = constructObjectPropertyCUInt "pulse" val++data CellRendererSpinnerPulsePropertyInfo+instance AttrInfo CellRendererSpinnerPulsePropertyInfo where+    type AttrAllowedOps CellRendererSpinnerPulsePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinnerPulsePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint CellRendererSpinnerPulsePropertyInfo = CellRendererSpinnerK+    type AttrGetType CellRendererSpinnerPulsePropertyInfo = Word32+    type AttrLabel CellRendererSpinnerPulsePropertyInfo = "CellRendererSpinner::pulse"+    attrGet _ = getCellRendererSpinnerPulse+    attrSet _ = setCellRendererSpinnerPulse+    attrConstruct _ = constructCellRendererSpinnerPulse++-- VVV Prop "size"+   -- Type: TInterface "Gtk" "IconSize"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererSpinnerSize :: (MonadIO m, CellRendererSpinnerK o) => o -> m IconSize+getCellRendererSpinnerSize obj = liftIO $ getObjectPropertyEnum obj "size"++setCellRendererSpinnerSize :: (MonadIO m, CellRendererSpinnerK o) => o -> IconSize -> m ()+setCellRendererSpinnerSize obj val = liftIO $ setObjectPropertyEnum obj "size" val++constructCellRendererSpinnerSize :: IconSize -> IO ([Char], GValue)+constructCellRendererSpinnerSize val = constructObjectPropertyEnum "size" val++data CellRendererSpinnerSizePropertyInfo+instance AttrInfo CellRendererSpinnerSizePropertyInfo where+    type AttrAllowedOps CellRendererSpinnerSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererSpinnerSizePropertyInfo = (~) IconSize+    type AttrBaseTypeConstraint CellRendererSpinnerSizePropertyInfo = CellRendererSpinnerK+    type AttrGetType CellRendererSpinnerSizePropertyInfo = IconSize+    type AttrLabel CellRendererSpinnerSizePropertyInfo = "CellRendererSpinner::size"+    attrGet _ = getCellRendererSpinnerSize+    attrSet _ = setCellRendererSpinnerSize+    attrConstruct _ = constructCellRendererSpinnerSize++type instance AttributeList CellRendererSpinner = CellRendererSpinnerAttributeList+type CellRendererSpinnerAttributeList = ('[ '("active", CellRendererSpinnerActivePropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("pulse", CellRendererSpinnerPulsePropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("size", CellRendererSpinnerSizePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellRendererSpinner = CellRendererSpinnerSignalList+type CellRendererSpinnerSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererSpinner::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererSpinner"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_spinner_new" gtk_cell_renderer_spinner_new :: +    IO (Ptr CellRendererSpinner)+++cellRendererSpinnerNew ::+    (MonadIO m) =>+    m CellRendererSpinner+cellRendererSpinnerNew  = liftIO $ do+    result <- gtk_cell_renderer_spinner_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_spinner_new" result+    result' <- (newObject CellRendererSpinner) result+    return result'++
+ GI/Gtk/Objects/CellRendererSpinner.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.CellRendererSpinner where++import Prelude ()+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 CellRendererSpinner = CellRendererSpinner (ForeignPtr CellRendererSpinner)+instance GObject CellRendererSpinner where+class GObject o => CellRendererSpinnerK o+instance (GObject o, IsDescendantOf CellRendererSpinner o) => CellRendererSpinnerK o+data CellRendererSpinnerActivePropertyInfo+data CellRendererSpinnerPulsePropertyInfo+data CellRendererSpinnerSizePropertyInfo
+ GI/Gtk/Objects/CellRendererText.hs view
@@ -0,0 +1,1664 @@++{- |+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.Gtk.Objects.CellRendererText+    ( ++-- * Exported types+    CellRendererText(..)                    ,+    CellRendererTextK                       ,+    toCellRendererText                      ,+    noCellRendererText                      ,+++ -- * Methods+-- ** cellRendererTextNew+    cellRendererTextNew                     ,+++-- ** cellRendererTextSetFixedHeightFromFont+    cellRendererTextSetFixedHeightFromFont  ,+++++ -- * Properties+-- ** AlignSet+    CellRendererTextAlignSetPropertyInfo    ,+    constructCellRendererTextAlignSet       ,+    getCellRendererTextAlignSet             ,+    setCellRendererTextAlignSet             ,+++-- ** Alignment+    CellRendererTextAlignmentPropertyInfo   ,+    constructCellRendererTextAlignment      ,+    getCellRendererTextAlignment            ,+    setCellRendererTextAlignment            ,+++-- ** Attributes+    CellRendererTextAttributesPropertyInfo  ,+    constructCellRendererTextAttributes     ,+    getCellRendererTextAttributes           ,+    setCellRendererTextAttributes           ,+++-- ** Background+    CellRendererTextBackgroundPropertyInfo  ,+    constructCellRendererTextBackground     ,+    setCellRendererTextBackground           ,+++-- ** BackgroundGdk+    CellRendererTextBackgroundGdkPropertyInfo,+    constructCellRendererTextBackgroundGdk  ,+    getCellRendererTextBackgroundGdk        ,+    setCellRendererTextBackgroundGdk        ,+++-- ** BackgroundRgba+    CellRendererTextBackgroundRgbaPropertyInfo,+    constructCellRendererTextBackgroundRgba ,+    getCellRendererTextBackgroundRgba       ,+    setCellRendererTextBackgroundRgba       ,+++-- ** BackgroundSet+    CellRendererTextBackgroundSetPropertyInfo,+    constructCellRendererTextBackgroundSet  ,+    getCellRendererTextBackgroundSet        ,+    setCellRendererTextBackgroundSet        ,+++-- ** Editable+    CellRendererTextEditablePropertyInfo    ,+    constructCellRendererTextEditable       ,+    getCellRendererTextEditable             ,+    setCellRendererTextEditable             ,+++-- ** EditableSet+    CellRendererTextEditableSetPropertyInfo ,+    constructCellRendererTextEditableSet    ,+    getCellRendererTextEditableSet          ,+    setCellRendererTextEditableSet          ,+++-- ** Ellipsize+    CellRendererTextEllipsizePropertyInfo   ,+    constructCellRendererTextEllipsize      ,+    getCellRendererTextEllipsize            ,+    setCellRendererTextEllipsize            ,+++-- ** EllipsizeSet+    CellRendererTextEllipsizeSetPropertyInfo,+    constructCellRendererTextEllipsizeSet   ,+    getCellRendererTextEllipsizeSet         ,+    setCellRendererTextEllipsizeSet         ,+++-- ** Family+    CellRendererTextFamilyPropertyInfo      ,+    constructCellRendererTextFamily         ,+    getCellRendererTextFamily               ,+    setCellRendererTextFamily               ,+++-- ** FamilySet+    CellRendererTextFamilySetPropertyInfo   ,+    constructCellRendererTextFamilySet      ,+    getCellRendererTextFamilySet            ,+    setCellRendererTextFamilySet            ,+++-- ** Font+    CellRendererTextFontPropertyInfo        ,+    constructCellRendererTextFont           ,+    getCellRendererTextFont                 ,+    setCellRendererTextFont                 ,+++-- ** FontDesc+    CellRendererTextFontDescPropertyInfo    ,+    constructCellRendererTextFontDesc       ,+    getCellRendererTextFontDesc             ,+    setCellRendererTextFontDesc             ,+++-- ** Foreground+    CellRendererTextForegroundPropertyInfo  ,+    constructCellRendererTextForeground     ,+    setCellRendererTextForeground           ,+++-- ** ForegroundGdk+    CellRendererTextForegroundGdkPropertyInfo,+    constructCellRendererTextForegroundGdk  ,+    getCellRendererTextForegroundGdk        ,+    setCellRendererTextForegroundGdk        ,+++-- ** ForegroundRgba+    CellRendererTextForegroundRgbaPropertyInfo,+    constructCellRendererTextForegroundRgba ,+    getCellRendererTextForegroundRgba       ,+    setCellRendererTextForegroundRgba       ,+++-- ** ForegroundSet+    CellRendererTextForegroundSetPropertyInfo,+    constructCellRendererTextForegroundSet  ,+    getCellRendererTextForegroundSet        ,+    setCellRendererTextForegroundSet        ,+++-- ** Language+    CellRendererTextLanguagePropertyInfo    ,+    constructCellRendererTextLanguage       ,+    getCellRendererTextLanguage             ,+    setCellRendererTextLanguage             ,+++-- ** LanguageSet+    CellRendererTextLanguageSetPropertyInfo ,+    constructCellRendererTextLanguageSet    ,+    getCellRendererTextLanguageSet          ,+    setCellRendererTextLanguageSet          ,+++-- ** Markup+    CellRendererTextMarkupPropertyInfo      ,+    constructCellRendererTextMarkup         ,+    setCellRendererTextMarkup               ,+++-- ** MaxWidthChars+    CellRendererTextMaxWidthCharsPropertyInfo,+    constructCellRendererTextMaxWidthChars  ,+    getCellRendererTextMaxWidthChars        ,+    setCellRendererTextMaxWidthChars        ,+++-- ** PlaceholderText+    CellRendererTextPlaceholderTextPropertyInfo,+    constructCellRendererTextPlaceholderText,+    getCellRendererTextPlaceholderText      ,+    setCellRendererTextPlaceholderText      ,+++-- ** Rise+    CellRendererTextRisePropertyInfo        ,+    constructCellRendererTextRise           ,+    getCellRendererTextRise                 ,+    setCellRendererTextRise                 ,+++-- ** RiseSet+    CellRendererTextRiseSetPropertyInfo     ,+    constructCellRendererTextRiseSet        ,+    getCellRendererTextRiseSet              ,+    setCellRendererTextRiseSet              ,+++-- ** Scale+    CellRendererTextScalePropertyInfo       ,+    constructCellRendererTextScale          ,+    getCellRendererTextScale                ,+    setCellRendererTextScale                ,+++-- ** ScaleSet+    CellRendererTextScaleSetPropertyInfo    ,+    constructCellRendererTextScaleSet       ,+    getCellRendererTextScaleSet             ,+    setCellRendererTextScaleSet             ,+++-- ** SingleParagraphMode+    CellRendererTextSingleParagraphModePropertyInfo,+    constructCellRendererTextSingleParagraphMode,+    getCellRendererTextSingleParagraphMode  ,+    setCellRendererTextSingleParagraphMode  ,+++-- ** Size+    CellRendererTextSizePropertyInfo        ,+    constructCellRendererTextSize           ,+    getCellRendererTextSize                 ,+    setCellRendererTextSize                 ,+++-- ** SizePoints+    CellRendererTextSizePointsPropertyInfo  ,+    constructCellRendererTextSizePoints     ,+    getCellRendererTextSizePoints           ,+    setCellRendererTextSizePoints           ,+++-- ** SizeSet+    CellRendererTextSizeSetPropertyInfo     ,+    constructCellRendererTextSizeSet        ,+    getCellRendererTextSizeSet              ,+    setCellRendererTextSizeSet              ,+++-- ** Stretch+    CellRendererTextStretchPropertyInfo     ,+    constructCellRendererTextStretch        ,+    getCellRendererTextStretch              ,+    setCellRendererTextStretch              ,+++-- ** StretchSet+    CellRendererTextStretchSetPropertyInfo  ,+    constructCellRendererTextStretchSet     ,+    getCellRendererTextStretchSet           ,+    setCellRendererTextStretchSet           ,+++-- ** Strikethrough+    CellRendererTextStrikethroughPropertyInfo,+    constructCellRendererTextStrikethrough  ,+    getCellRendererTextStrikethrough        ,+    setCellRendererTextStrikethrough        ,+++-- ** StrikethroughSet+    CellRendererTextStrikethroughSetPropertyInfo,+    constructCellRendererTextStrikethroughSet,+    getCellRendererTextStrikethroughSet     ,+    setCellRendererTextStrikethroughSet     ,+++-- ** Style+    CellRendererTextStylePropertyInfo       ,+    constructCellRendererTextStyle          ,+    getCellRendererTextStyle                ,+    setCellRendererTextStyle                ,+++-- ** StyleSet+    CellRendererTextStyleSetPropertyInfo    ,+    constructCellRendererTextStyleSet       ,+    getCellRendererTextStyleSet             ,+    setCellRendererTextStyleSet             ,+++-- ** Text+    CellRendererTextTextPropertyInfo        ,+    constructCellRendererTextText           ,+    getCellRendererTextText                 ,+    setCellRendererTextText                 ,+++-- ** Underline+    CellRendererTextUnderlinePropertyInfo   ,+    constructCellRendererTextUnderline      ,+    getCellRendererTextUnderline            ,+    setCellRendererTextUnderline            ,+++-- ** UnderlineSet+    CellRendererTextUnderlineSetPropertyInfo,+    constructCellRendererTextUnderlineSet   ,+    getCellRendererTextUnderlineSet         ,+    setCellRendererTextUnderlineSet         ,+++-- ** Variant+    CellRendererTextVariantPropertyInfo     ,+    constructCellRendererTextVariant        ,+    getCellRendererTextVariant              ,+    setCellRendererTextVariant              ,+++-- ** VariantSet+    CellRendererTextVariantSetPropertyInfo  ,+    constructCellRendererTextVariantSet     ,+    getCellRendererTextVariantSet           ,+    setCellRendererTextVariantSet           ,+++-- ** Weight+    CellRendererTextWeightPropertyInfo      ,+    constructCellRendererTextWeight         ,+    getCellRendererTextWeight               ,+    setCellRendererTextWeight               ,+++-- ** WeightSet+    CellRendererTextWeightSetPropertyInfo   ,+    constructCellRendererTextWeightSet      ,+    getCellRendererTextWeightSet            ,+    setCellRendererTextWeightSet            ,+++-- ** WidthChars+    CellRendererTextWidthCharsPropertyInfo  ,+    constructCellRendererTextWidthChars     ,+    getCellRendererTextWidthChars           ,+    setCellRendererTextWidthChars           ,+++-- ** WrapMode+    CellRendererTextWrapModePropertyInfo    ,+    constructCellRendererTextWrapMode       ,+    getCellRendererTextWrapMode             ,+    setCellRendererTextWrapMode             ,+++-- ** WrapWidth+    CellRendererTextWrapWidthPropertyInfo   ,+    constructCellRendererTextWrapWidth      ,+    getCellRendererTextWrapWidth            ,+    setCellRendererTextWrapWidth            ,+++++ -- * Signals+-- ** Edited+    CellRendererTextEditedCallback          ,+    CellRendererTextEditedCallbackC         ,+    CellRendererTextEditedSignalInfo        ,+    afterCellRendererTextEdited             ,+    cellRendererTextEditedCallbackWrapper   ,+    cellRendererTextEditedClosure           ,+    mkCellRendererTextEditedCallback        ,+    noCellRendererTextEditedCallback        ,+    onCellRendererTextEdited                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Pango as Pango++newtype CellRendererText = CellRendererText (ForeignPtr CellRendererText)+foreign import ccall "gtk_cell_renderer_text_get_type"+    c_gtk_cell_renderer_text_get_type :: IO GType++type instance ParentTypes CellRendererText = CellRendererTextParentTypes+type CellRendererTextParentTypes = '[CellRenderer, GObject.Object]++instance GObject CellRendererText where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_text_get_type+    ++class GObject o => CellRendererTextK o+instance (GObject o, IsDescendantOf CellRendererText o) => CellRendererTextK o++toCellRendererText :: CellRendererTextK o => o -> IO CellRendererText+toCellRendererText = unsafeCastTo CellRendererText++noCellRendererText :: Maybe CellRendererText+noCellRendererText = Nothing++-- signal CellRendererText::edited+type CellRendererTextEditedCallback =+    T.Text ->+    T.Text ->+    IO ()++noCellRendererTextEditedCallback :: Maybe CellRendererTextEditedCallback+noCellRendererTextEditedCallback = Nothing++type CellRendererTextEditedCallbackC =+    Ptr () ->                               -- object+    CString ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererTextEditedCallback :: CellRendererTextEditedCallbackC -> IO (FunPtr CellRendererTextEditedCallbackC)++cellRendererTextEditedClosure :: CellRendererTextEditedCallback -> IO Closure+cellRendererTextEditedClosure cb = newCClosure =<< mkCellRendererTextEditedCallback wrapped+    where wrapped = cellRendererTextEditedCallbackWrapper cb++cellRendererTextEditedCallbackWrapper ::+    CellRendererTextEditedCallback ->+    Ptr () ->+    CString ->+    CString ->+    Ptr () ->+    IO ()+cellRendererTextEditedCallbackWrapper _cb _ path new_text _ = do+    path' <- cstringToText path+    new_text' <- cstringToText new_text+    _cb  path' new_text'++onCellRendererTextEdited :: (GObject a, MonadIO m) => a -> CellRendererTextEditedCallback -> m SignalHandlerId+onCellRendererTextEdited obj cb = liftIO $ connectCellRendererTextEdited obj cb SignalConnectBefore+afterCellRendererTextEdited :: (GObject a, MonadIO m) => a -> CellRendererTextEditedCallback -> m SignalHandlerId+afterCellRendererTextEdited obj cb = connectCellRendererTextEdited obj cb SignalConnectAfter++connectCellRendererTextEdited :: (GObject a, MonadIO m) =>+                                 a -> CellRendererTextEditedCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererTextEdited obj cb after = liftIO $ do+    cb' <- mkCellRendererTextEditedCallback (cellRendererTextEditedCallbackWrapper cb)+    connectSignalFunPtr obj "edited" cb' after++-- VVV Prop "align-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextAlignSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextAlignSet obj = liftIO $ getObjectPropertyBool obj "align-set"++setCellRendererTextAlignSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextAlignSet obj val = liftIO $ setObjectPropertyBool obj "align-set" val++constructCellRendererTextAlignSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextAlignSet val = constructObjectPropertyBool "align-set" val++data CellRendererTextAlignSetPropertyInfo+instance AttrInfo CellRendererTextAlignSetPropertyInfo where+    type AttrAllowedOps CellRendererTextAlignSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextAlignSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextAlignSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextAlignSetPropertyInfo = Bool+    type AttrLabel CellRendererTextAlignSetPropertyInfo = "CellRendererText::align-set"+    attrGet _ = getCellRendererTextAlignSet+    attrSet _ = setCellRendererTextAlignSet+    attrConstruct _ = constructCellRendererTextAlignSet++-- VVV Prop "alignment"+   -- Type: TInterface "Pango" "Alignment"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextAlignment :: (MonadIO m, CellRendererTextK o) => o -> m Pango.Alignment+getCellRendererTextAlignment obj = liftIO $ getObjectPropertyEnum obj "alignment"++setCellRendererTextAlignment :: (MonadIO m, CellRendererTextK o) => o -> Pango.Alignment -> m ()+setCellRendererTextAlignment obj val = liftIO $ setObjectPropertyEnum obj "alignment" val++constructCellRendererTextAlignment :: Pango.Alignment -> IO ([Char], GValue)+constructCellRendererTextAlignment val = constructObjectPropertyEnum "alignment" val++data CellRendererTextAlignmentPropertyInfo+instance AttrInfo CellRendererTextAlignmentPropertyInfo where+    type AttrAllowedOps CellRendererTextAlignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextAlignmentPropertyInfo = (~) Pango.Alignment+    type AttrBaseTypeConstraint CellRendererTextAlignmentPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextAlignmentPropertyInfo = Pango.Alignment+    type AttrLabel CellRendererTextAlignmentPropertyInfo = "CellRendererText::alignment"+    attrGet _ = getCellRendererTextAlignment+    attrSet _ = setCellRendererTextAlignment+    attrConstruct _ = constructCellRendererTextAlignment++-- VVV Prop "attributes"+   -- Type: TInterface "Pango" "AttrList"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextAttributes :: (MonadIO m, CellRendererTextK o) => o -> m Pango.AttrList+getCellRendererTextAttributes obj = liftIO $ getObjectPropertyBoxed obj "attributes" Pango.AttrList++setCellRendererTextAttributes :: (MonadIO m, CellRendererTextK o) => o -> Pango.AttrList -> m ()+setCellRendererTextAttributes obj val = liftIO $ setObjectPropertyBoxed obj "attributes" val++constructCellRendererTextAttributes :: Pango.AttrList -> IO ([Char], GValue)+constructCellRendererTextAttributes val = constructObjectPropertyBoxed "attributes" val++data CellRendererTextAttributesPropertyInfo+instance AttrInfo CellRendererTextAttributesPropertyInfo where+    type AttrAllowedOps CellRendererTextAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextAttributesPropertyInfo = (~) Pango.AttrList+    type AttrBaseTypeConstraint CellRendererTextAttributesPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextAttributesPropertyInfo = Pango.AttrList+    type AttrLabel CellRendererTextAttributesPropertyInfo = "CellRendererText::attributes"+    attrGet _ = getCellRendererTextAttributes+    attrSet _ = setCellRendererTextAttributes+    attrConstruct _ = constructCellRendererTextAttributes++-- VVV Prop "background"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setCellRendererTextBackground :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextBackground obj val = liftIO $ setObjectPropertyString obj "background" val++constructCellRendererTextBackground :: T.Text -> IO ([Char], GValue)+constructCellRendererTextBackground val = constructObjectPropertyString "background" val++data CellRendererTextBackgroundPropertyInfo+instance AttrInfo CellRendererTextBackgroundPropertyInfo where+    type AttrAllowedOps CellRendererTextBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint CellRendererTextBackgroundPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextBackgroundPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextBackgroundPropertyInfo = ()+    type AttrLabel CellRendererTextBackgroundPropertyInfo = "CellRendererText::background"+    attrGet _ = undefined+    attrSet _ = setCellRendererTextBackground+    attrConstruct _ = constructCellRendererTextBackground++-- VVV Prop "background-gdk"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextBackgroundGdk :: (MonadIO m, CellRendererTextK o) => o -> m Gdk.Color+getCellRendererTextBackgroundGdk obj = liftIO $ getObjectPropertyBoxed obj "background-gdk" Gdk.Color++setCellRendererTextBackgroundGdk :: (MonadIO m, CellRendererTextK o) => o -> Gdk.Color -> m ()+setCellRendererTextBackgroundGdk obj val = liftIO $ setObjectPropertyBoxed obj "background-gdk" val++constructCellRendererTextBackgroundGdk :: Gdk.Color -> IO ([Char], GValue)+constructCellRendererTextBackgroundGdk val = constructObjectPropertyBoxed "background-gdk" val++data CellRendererTextBackgroundGdkPropertyInfo+instance AttrInfo CellRendererTextBackgroundGdkPropertyInfo where+    type AttrAllowedOps CellRendererTextBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextBackgroundGdkPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint CellRendererTextBackgroundGdkPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextBackgroundGdkPropertyInfo = Gdk.Color+    type AttrLabel CellRendererTextBackgroundGdkPropertyInfo = "CellRendererText::background-gdk"+    attrGet _ = getCellRendererTextBackgroundGdk+    attrSet _ = setCellRendererTextBackgroundGdk+    attrConstruct _ = constructCellRendererTextBackgroundGdk++-- VVV Prop "background-rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextBackgroundRgba :: (MonadIO m, CellRendererTextK o) => o -> m Gdk.RGBA+getCellRendererTextBackgroundRgba obj = liftIO $ getObjectPropertyBoxed obj "background-rgba" Gdk.RGBA++setCellRendererTextBackgroundRgba :: (MonadIO m, CellRendererTextK o) => o -> Gdk.RGBA -> m ()+setCellRendererTextBackgroundRgba obj val = liftIO $ setObjectPropertyBoxed obj "background-rgba" val++constructCellRendererTextBackgroundRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructCellRendererTextBackgroundRgba val = constructObjectPropertyBoxed "background-rgba" val++data CellRendererTextBackgroundRgbaPropertyInfo+instance AttrInfo CellRendererTextBackgroundRgbaPropertyInfo where+    type AttrAllowedOps CellRendererTextBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextBackgroundRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint CellRendererTextBackgroundRgbaPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextBackgroundRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel CellRendererTextBackgroundRgbaPropertyInfo = "CellRendererText::background-rgba"+    attrGet _ = getCellRendererTextBackgroundRgba+    attrSet _ = setCellRendererTextBackgroundRgba+    attrConstruct _ = constructCellRendererTextBackgroundRgba++-- VVV Prop "background-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextBackgroundSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextBackgroundSet obj = liftIO $ getObjectPropertyBool obj "background-set"++setCellRendererTextBackgroundSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextBackgroundSet obj val = liftIO $ setObjectPropertyBool obj "background-set" val++constructCellRendererTextBackgroundSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextBackgroundSet val = constructObjectPropertyBool "background-set" val++data CellRendererTextBackgroundSetPropertyInfo+instance AttrInfo CellRendererTextBackgroundSetPropertyInfo where+    type AttrAllowedOps CellRendererTextBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextBackgroundSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextBackgroundSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextBackgroundSetPropertyInfo = Bool+    type AttrLabel CellRendererTextBackgroundSetPropertyInfo = "CellRendererText::background-set"+    attrGet _ = getCellRendererTextBackgroundSet+    attrSet _ = setCellRendererTextBackgroundSet+    attrConstruct _ = constructCellRendererTextBackgroundSet++-- VVV Prop "editable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextEditable :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextEditable obj = liftIO $ getObjectPropertyBool obj "editable"++setCellRendererTextEditable :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextEditable obj val = liftIO $ setObjectPropertyBool obj "editable" val++constructCellRendererTextEditable :: Bool -> IO ([Char], GValue)+constructCellRendererTextEditable val = constructObjectPropertyBool "editable" val++data CellRendererTextEditablePropertyInfo+instance AttrInfo CellRendererTextEditablePropertyInfo where+    type AttrAllowedOps CellRendererTextEditablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextEditablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextEditablePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextEditablePropertyInfo = Bool+    type AttrLabel CellRendererTextEditablePropertyInfo = "CellRendererText::editable"+    attrGet _ = getCellRendererTextEditable+    attrSet _ = setCellRendererTextEditable+    attrConstruct _ = constructCellRendererTextEditable++-- VVV Prop "editable-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextEditableSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextEditableSet obj = liftIO $ getObjectPropertyBool obj "editable-set"++setCellRendererTextEditableSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextEditableSet obj val = liftIO $ setObjectPropertyBool obj "editable-set" val++constructCellRendererTextEditableSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextEditableSet val = constructObjectPropertyBool "editable-set" val++data CellRendererTextEditableSetPropertyInfo+instance AttrInfo CellRendererTextEditableSetPropertyInfo where+    type AttrAllowedOps CellRendererTextEditableSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextEditableSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextEditableSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextEditableSetPropertyInfo = Bool+    type AttrLabel CellRendererTextEditableSetPropertyInfo = "CellRendererText::editable-set"+    attrGet _ = getCellRendererTextEditableSet+    attrSet _ = setCellRendererTextEditableSet+    attrConstruct _ = constructCellRendererTextEditableSet++-- VVV Prop "ellipsize"+   -- Type: TInterface "Pango" "EllipsizeMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextEllipsize :: (MonadIO m, CellRendererTextK o) => o -> m Pango.EllipsizeMode+getCellRendererTextEllipsize obj = liftIO $ getObjectPropertyEnum obj "ellipsize"++setCellRendererTextEllipsize :: (MonadIO m, CellRendererTextK o) => o -> Pango.EllipsizeMode -> m ()+setCellRendererTextEllipsize obj val = liftIO $ setObjectPropertyEnum obj "ellipsize" val++constructCellRendererTextEllipsize :: Pango.EllipsizeMode -> IO ([Char], GValue)+constructCellRendererTextEllipsize val = constructObjectPropertyEnum "ellipsize" val++data CellRendererTextEllipsizePropertyInfo+instance AttrInfo CellRendererTextEllipsizePropertyInfo where+    type AttrAllowedOps CellRendererTextEllipsizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextEllipsizePropertyInfo = (~) Pango.EllipsizeMode+    type AttrBaseTypeConstraint CellRendererTextEllipsizePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextEllipsizePropertyInfo = Pango.EllipsizeMode+    type AttrLabel CellRendererTextEllipsizePropertyInfo = "CellRendererText::ellipsize"+    attrGet _ = getCellRendererTextEllipsize+    attrSet _ = setCellRendererTextEllipsize+    attrConstruct _ = constructCellRendererTextEllipsize++-- VVV Prop "ellipsize-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextEllipsizeSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextEllipsizeSet obj = liftIO $ getObjectPropertyBool obj "ellipsize-set"++setCellRendererTextEllipsizeSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextEllipsizeSet obj val = liftIO $ setObjectPropertyBool obj "ellipsize-set" val++constructCellRendererTextEllipsizeSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextEllipsizeSet val = constructObjectPropertyBool "ellipsize-set" val++data CellRendererTextEllipsizeSetPropertyInfo+instance AttrInfo CellRendererTextEllipsizeSetPropertyInfo where+    type AttrAllowedOps CellRendererTextEllipsizeSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextEllipsizeSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextEllipsizeSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextEllipsizeSetPropertyInfo = Bool+    type AttrLabel CellRendererTextEllipsizeSetPropertyInfo = "CellRendererText::ellipsize-set"+    attrGet _ = getCellRendererTextEllipsizeSet+    attrSet _ = setCellRendererTextEllipsizeSet+    attrConstruct _ = constructCellRendererTextEllipsizeSet++-- VVV Prop "family"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextFamily :: (MonadIO m, CellRendererTextK o) => o -> m T.Text+getCellRendererTextFamily obj = liftIO $ getObjectPropertyString obj "family"++setCellRendererTextFamily :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextFamily obj val = liftIO $ setObjectPropertyString obj "family" val++constructCellRendererTextFamily :: T.Text -> IO ([Char], GValue)+constructCellRendererTextFamily val = constructObjectPropertyString "family" val++data CellRendererTextFamilyPropertyInfo+instance AttrInfo CellRendererTextFamilyPropertyInfo where+    type AttrAllowedOps CellRendererTextFamilyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextFamilyPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextFamilyPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextFamilyPropertyInfo = T.Text+    type AttrLabel CellRendererTextFamilyPropertyInfo = "CellRendererText::family"+    attrGet _ = getCellRendererTextFamily+    attrSet _ = setCellRendererTextFamily+    attrConstruct _ = constructCellRendererTextFamily++-- VVV Prop "family-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextFamilySet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextFamilySet obj = liftIO $ getObjectPropertyBool obj "family-set"++setCellRendererTextFamilySet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextFamilySet obj val = liftIO $ setObjectPropertyBool obj "family-set" val++constructCellRendererTextFamilySet :: Bool -> IO ([Char], GValue)+constructCellRendererTextFamilySet val = constructObjectPropertyBool "family-set" val++data CellRendererTextFamilySetPropertyInfo+instance AttrInfo CellRendererTextFamilySetPropertyInfo where+    type AttrAllowedOps CellRendererTextFamilySetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextFamilySetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextFamilySetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextFamilySetPropertyInfo = Bool+    type AttrLabel CellRendererTextFamilySetPropertyInfo = "CellRendererText::family-set"+    attrGet _ = getCellRendererTextFamilySet+    attrSet _ = setCellRendererTextFamilySet+    attrConstruct _ = constructCellRendererTextFamilySet++-- VVV Prop "font"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextFont :: (MonadIO m, CellRendererTextK o) => o -> m T.Text+getCellRendererTextFont obj = liftIO $ getObjectPropertyString obj "font"++setCellRendererTextFont :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextFont obj val = liftIO $ setObjectPropertyString obj "font" val++constructCellRendererTextFont :: T.Text -> IO ([Char], GValue)+constructCellRendererTextFont val = constructObjectPropertyString "font" val++data CellRendererTextFontPropertyInfo+instance AttrInfo CellRendererTextFontPropertyInfo where+    type AttrAllowedOps CellRendererTextFontPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextFontPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextFontPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextFontPropertyInfo = T.Text+    type AttrLabel CellRendererTextFontPropertyInfo = "CellRendererText::font"+    attrGet _ = getCellRendererTextFont+    attrSet _ = setCellRendererTextFont+    attrConstruct _ = constructCellRendererTextFont++-- VVV Prop "font-desc"+   -- Type: TInterface "Pango" "FontDescription"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextFontDesc :: (MonadIO m, CellRendererTextK o) => o -> m Pango.FontDescription+getCellRendererTextFontDesc obj = liftIO $ getObjectPropertyBoxed obj "font-desc" Pango.FontDescription++setCellRendererTextFontDesc :: (MonadIO m, CellRendererTextK o) => o -> Pango.FontDescription -> m ()+setCellRendererTextFontDesc obj val = liftIO $ setObjectPropertyBoxed obj "font-desc" val++constructCellRendererTextFontDesc :: Pango.FontDescription -> IO ([Char], GValue)+constructCellRendererTextFontDesc val = constructObjectPropertyBoxed "font-desc" val++data CellRendererTextFontDescPropertyInfo+instance AttrInfo CellRendererTextFontDescPropertyInfo where+    type AttrAllowedOps CellRendererTextFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextFontDescPropertyInfo = (~) Pango.FontDescription+    type AttrBaseTypeConstraint CellRendererTextFontDescPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextFontDescPropertyInfo = Pango.FontDescription+    type AttrLabel CellRendererTextFontDescPropertyInfo = "CellRendererText::font-desc"+    attrGet _ = getCellRendererTextFontDesc+    attrSet _ = setCellRendererTextFontDesc+    attrConstruct _ = constructCellRendererTextFontDesc++-- VVV Prop "foreground"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setCellRendererTextForeground :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextForeground obj val = liftIO $ setObjectPropertyString obj "foreground" val++constructCellRendererTextForeground :: T.Text -> IO ([Char], GValue)+constructCellRendererTextForeground val = constructObjectPropertyString "foreground" val++data CellRendererTextForegroundPropertyInfo+instance AttrInfo CellRendererTextForegroundPropertyInfo where+    type AttrAllowedOps CellRendererTextForegroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint CellRendererTextForegroundPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextForegroundPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextForegroundPropertyInfo = ()+    type AttrLabel CellRendererTextForegroundPropertyInfo = "CellRendererText::foreground"+    attrGet _ = undefined+    attrSet _ = setCellRendererTextForeground+    attrConstruct _ = constructCellRendererTextForeground++-- VVV Prop "foreground-gdk"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextForegroundGdk :: (MonadIO m, CellRendererTextK o) => o -> m Gdk.Color+getCellRendererTextForegroundGdk obj = liftIO $ getObjectPropertyBoxed obj "foreground-gdk" Gdk.Color++setCellRendererTextForegroundGdk :: (MonadIO m, CellRendererTextK o) => o -> Gdk.Color -> m ()+setCellRendererTextForegroundGdk obj val = liftIO $ setObjectPropertyBoxed obj "foreground-gdk" val++constructCellRendererTextForegroundGdk :: Gdk.Color -> IO ([Char], GValue)+constructCellRendererTextForegroundGdk val = constructObjectPropertyBoxed "foreground-gdk" val++data CellRendererTextForegroundGdkPropertyInfo+instance AttrInfo CellRendererTextForegroundGdkPropertyInfo where+    type AttrAllowedOps CellRendererTextForegroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextForegroundGdkPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint CellRendererTextForegroundGdkPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextForegroundGdkPropertyInfo = Gdk.Color+    type AttrLabel CellRendererTextForegroundGdkPropertyInfo = "CellRendererText::foreground-gdk"+    attrGet _ = getCellRendererTextForegroundGdk+    attrSet _ = setCellRendererTextForegroundGdk+    attrConstruct _ = constructCellRendererTextForegroundGdk++-- VVV Prop "foreground-rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextForegroundRgba :: (MonadIO m, CellRendererTextK o) => o -> m Gdk.RGBA+getCellRendererTextForegroundRgba obj = liftIO $ getObjectPropertyBoxed obj "foreground-rgba" Gdk.RGBA++setCellRendererTextForegroundRgba :: (MonadIO m, CellRendererTextK o) => o -> Gdk.RGBA -> m ()+setCellRendererTextForegroundRgba obj val = liftIO $ setObjectPropertyBoxed obj "foreground-rgba" val++constructCellRendererTextForegroundRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructCellRendererTextForegroundRgba val = constructObjectPropertyBoxed "foreground-rgba" val++data CellRendererTextForegroundRgbaPropertyInfo+instance AttrInfo CellRendererTextForegroundRgbaPropertyInfo where+    type AttrAllowedOps CellRendererTextForegroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextForegroundRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint CellRendererTextForegroundRgbaPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextForegroundRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel CellRendererTextForegroundRgbaPropertyInfo = "CellRendererText::foreground-rgba"+    attrGet _ = getCellRendererTextForegroundRgba+    attrSet _ = setCellRendererTextForegroundRgba+    attrConstruct _ = constructCellRendererTextForegroundRgba++-- VVV Prop "foreground-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextForegroundSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextForegroundSet obj = liftIO $ getObjectPropertyBool obj "foreground-set"++setCellRendererTextForegroundSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextForegroundSet obj val = liftIO $ setObjectPropertyBool obj "foreground-set" val++constructCellRendererTextForegroundSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextForegroundSet val = constructObjectPropertyBool "foreground-set" val++data CellRendererTextForegroundSetPropertyInfo+instance AttrInfo CellRendererTextForegroundSetPropertyInfo where+    type AttrAllowedOps CellRendererTextForegroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextForegroundSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextForegroundSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextForegroundSetPropertyInfo = Bool+    type AttrLabel CellRendererTextForegroundSetPropertyInfo = "CellRendererText::foreground-set"+    attrGet _ = getCellRendererTextForegroundSet+    attrSet _ = setCellRendererTextForegroundSet+    attrConstruct _ = constructCellRendererTextForegroundSet++-- VVV Prop "language"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextLanguage :: (MonadIO m, CellRendererTextK o) => o -> m T.Text+getCellRendererTextLanguage obj = liftIO $ getObjectPropertyString obj "language"++setCellRendererTextLanguage :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextLanguage obj val = liftIO $ setObjectPropertyString obj "language" val++constructCellRendererTextLanguage :: T.Text -> IO ([Char], GValue)+constructCellRendererTextLanguage val = constructObjectPropertyString "language" val++data CellRendererTextLanguagePropertyInfo+instance AttrInfo CellRendererTextLanguagePropertyInfo where+    type AttrAllowedOps CellRendererTextLanguagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextLanguagePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextLanguagePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextLanguagePropertyInfo = T.Text+    type AttrLabel CellRendererTextLanguagePropertyInfo = "CellRendererText::language"+    attrGet _ = getCellRendererTextLanguage+    attrSet _ = setCellRendererTextLanguage+    attrConstruct _ = constructCellRendererTextLanguage++-- VVV Prop "language-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextLanguageSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextLanguageSet obj = liftIO $ getObjectPropertyBool obj "language-set"++setCellRendererTextLanguageSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextLanguageSet obj val = liftIO $ setObjectPropertyBool obj "language-set" val++constructCellRendererTextLanguageSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextLanguageSet val = constructObjectPropertyBool "language-set" val++data CellRendererTextLanguageSetPropertyInfo+instance AttrInfo CellRendererTextLanguageSetPropertyInfo where+    type AttrAllowedOps CellRendererTextLanguageSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextLanguageSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextLanguageSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextLanguageSetPropertyInfo = Bool+    type AttrLabel CellRendererTextLanguageSetPropertyInfo = "CellRendererText::language-set"+    attrGet _ = getCellRendererTextLanguageSet+    attrSet _ = setCellRendererTextLanguageSet+    attrConstruct _ = constructCellRendererTextLanguageSet++-- VVV Prop "markup"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setCellRendererTextMarkup :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextMarkup obj val = liftIO $ setObjectPropertyString obj "markup" val++constructCellRendererTextMarkup :: T.Text -> IO ([Char], GValue)+constructCellRendererTextMarkup val = constructObjectPropertyString "markup" val++data CellRendererTextMarkupPropertyInfo+instance AttrInfo CellRendererTextMarkupPropertyInfo where+    type AttrAllowedOps CellRendererTextMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint CellRendererTextMarkupPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextMarkupPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextMarkupPropertyInfo = ()+    type AttrLabel CellRendererTextMarkupPropertyInfo = "CellRendererText::markup"+    attrGet _ = undefined+    attrSet _ = setCellRendererTextMarkup+    attrConstruct _ = constructCellRendererTextMarkup++-- VVV Prop "max-width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextMaxWidthChars :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextMaxWidthChars obj = liftIO $ getObjectPropertyCInt obj "max-width-chars"++setCellRendererTextMaxWidthChars :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextMaxWidthChars obj val = liftIO $ setObjectPropertyCInt obj "max-width-chars" val++constructCellRendererTextMaxWidthChars :: Int32 -> IO ([Char], GValue)+constructCellRendererTextMaxWidthChars val = constructObjectPropertyCInt "max-width-chars" val++data CellRendererTextMaxWidthCharsPropertyInfo+instance AttrInfo CellRendererTextMaxWidthCharsPropertyInfo where+    type AttrAllowedOps CellRendererTextMaxWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextMaxWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextMaxWidthCharsPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextMaxWidthCharsPropertyInfo = Int32+    type AttrLabel CellRendererTextMaxWidthCharsPropertyInfo = "CellRendererText::max-width-chars"+    attrGet _ = getCellRendererTextMaxWidthChars+    attrSet _ = setCellRendererTextMaxWidthChars+    attrConstruct _ = constructCellRendererTextMaxWidthChars++-- VVV Prop "placeholder-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextPlaceholderText :: (MonadIO m, CellRendererTextK o) => o -> m T.Text+getCellRendererTextPlaceholderText obj = liftIO $ getObjectPropertyString obj "placeholder-text"++setCellRendererTextPlaceholderText :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextPlaceholderText obj val = liftIO $ setObjectPropertyString obj "placeholder-text" val++constructCellRendererTextPlaceholderText :: T.Text -> IO ([Char], GValue)+constructCellRendererTextPlaceholderText val = constructObjectPropertyString "placeholder-text" val++data CellRendererTextPlaceholderTextPropertyInfo+instance AttrInfo CellRendererTextPlaceholderTextPropertyInfo where+    type AttrAllowedOps CellRendererTextPlaceholderTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextPlaceholderTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextPlaceholderTextPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextPlaceholderTextPropertyInfo = T.Text+    type AttrLabel CellRendererTextPlaceholderTextPropertyInfo = "CellRendererText::placeholder-text"+    attrGet _ = getCellRendererTextPlaceholderText+    attrSet _ = setCellRendererTextPlaceholderText+    attrConstruct _ = constructCellRendererTextPlaceholderText++-- VVV Prop "rise"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextRise :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextRise obj = liftIO $ getObjectPropertyCInt obj "rise"++setCellRendererTextRise :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextRise obj val = liftIO $ setObjectPropertyCInt obj "rise" val++constructCellRendererTextRise :: Int32 -> IO ([Char], GValue)+constructCellRendererTextRise val = constructObjectPropertyCInt "rise" val++data CellRendererTextRisePropertyInfo+instance AttrInfo CellRendererTextRisePropertyInfo where+    type AttrAllowedOps CellRendererTextRisePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextRisePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextRisePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextRisePropertyInfo = Int32+    type AttrLabel CellRendererTextRisePropertyInfo = "CellRendererText::rise"+    attrGet _ = getCellRendererTextRise+    attrSet _ = setCellRendererTextRise+    attrConstruct _ = constructCellRendererTextRise++-- VVV Prop "rise-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextRiseSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextRiseSet obj = liftIO $ getObjectPropertyBool obj "rise-set"++setCellRendererTextRiseSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextRiseSet obj val = liftIO $ setObjectPropertyBool obj "rise-set" val++constructCellRendererTextRiseSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextRiseSet val = constructObjectPropertyBool "rise-set" val++data CellRendererTextRiseSetPropertyInfo+instance AttrInfo CellRendererTextRiseSetPropertyInfo where+    type AttrAllowedOps CellRendererTextRiseSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextRiseSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextRiseSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextRiseSetPropertyInfo = Bool+    type AttrLabel CellRendererTextRiseSetPropertyInfo = "CellRendererText::rise-set"+    attrGet _ = getCellRendererTextRiseSet+    attrSet _ = setCellRendererTextRiseSet+    attrConstruct _ = constructCellRendererTextRiseSet++-- VVV Prop "scale"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextScale :: (MonadIO m, CellRendererTextK o) => o -> m Double+getCellRendererTextScale obj = liftIO $ getObjectPropertyDouble obj "scale"++setCellRendererTextScale :: (MonadIO m, CellRendererTextK o) => o -> Double -> m ()+setCellRendererTextScale obj val = liftIO $ setObjectPropertyDouble obj "scale" val++constructCellRendererTextScale :: Double -> IO ([Char], GValue)+constructCellRendererTextScale val = constructObjectPropertyDouble "scale" val++data CellRendererTextScalePropertyInfo+instance AttrInfo CellRendererTextScalePropertyInfo where+    type AttrAllowedOps CellRendererTextScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextScalePropertyInfo = (~) Double+    type AttrBaseTypeConstraint CellRendererTextScalePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextScalePropertyInfo = Double+    type AttrLabel CellRendererTextScalePropertyInfo = "CellRendererText::scale"+    attrGet _ = getCellRendererTextScale+    attrSet _ = setCellRendererTextScale+    attrConstruct _ = constructCellRendererTextScale++-- VVV Prop "scale-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextScaleSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextScaleSet obj = liftIO $ getObjectPropertyBool obj "scale-set"++setCellRendererTextScaleSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextScaleSet obj val = liftIO $ setObjectPropertyBool obj "scale-set" val++constructCellRendererTextScaleSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextScaleSet val = constructObjectPropertyBool "scale-set" val++data CellRendererTextScaleSetPropertyInfo+instance AttrInfo CellRendererTextScaleSetPropertyInfo where+    type AttrAllowedOps CellRendererTextScaleSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextScaleSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextScaleSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextScaleSetPropertyInfo = Bool+    type AttrLabel CellRendererTextScaleSetPropertyInfo = "CellRendererText::scale-set"+    attrGet _ = getCellRendererTextScaleSet+    attrSet _ = setCellRendererTextScaleSet+    attrConstruct _ = constructCellRendererTextScaleSet++-- VVV Prop "single-paragraph-mode"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextSingleParagraphMode :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextSingleParagraphMode obj = liftIO $ getObjectPropertyBool obj "single-paragraph-mode"++setCellRendererTextSingleParagraphMode :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextSingleParagraphMode obj val = liftIO $ setObjectPropertyBool obj "single-paragraph-mode" val++constructCellRendererTextSingleParagraphMode :: Bool -> IO ([Char], GValue)+constructCellRendererTextSingleParagraphMode val = constructObjectPropertyBool "single-paragraph-mode" val++data CellRendererTextSingleParagraphModePropertyInfo+instance AttrInfo CellRendererTextSingleParagraphModePropertyInfo where+    type AttrAllowedOps CellRendererTextSingleParagraphModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextSingleParagraphModePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextSingleParagraphModePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextSingleParagraphModePropertyInfo = Bool+    type AttrLabel CellRendererTextSingleParagraphModePropertyInfo = "CellRendererText::single-paragraph-mode"+    attrGet _ = getCellRendererTextSingleParagraphMode+    attrSet _ = setCellRendererTextSingleParagraphMode+    attrConstruct _ = constructCellRendererTextSingleParagraphMode++-- VVV Prop "size"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextSize :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextSize obj = liftIO $ getObjectPropertyCInt obj "size"++setCellRendererTextSize :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextSize obj val = liftIO $ setObjectPropertyCInt obj "size" val++constructCellRendererTextSize :: Int32 -> IO ([Char], GValue)+constructCellRendererTextSize val = constructObjectPropertyCInt "size" val++data CellRendererTextSizePropertyInfo+instance AttrInfo CellRendererTextSizePropertyInfo where+    type AttrAllowedOps CellRendererTextSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextSizePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextSizePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextSizePropertyInfo = Int32+    type AttrLabel CellRendererTextSizePropertyInfo = "CellRendererText::size"+    attrGet _ = getCellRendererTextSize+    attrSet _ = setCellRendererTextSize+    attrConstruct _ = constructCellRendererTextSize++-- VVV Prop "size-points"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextSizePoints :: (MonadIO m, CellRendererTextK o) => o -> m Double+getCellRendererTextSizePoints obj = liftIO $ getObjectPropertyDouble obj "size-points"++setCellRendererTextSizePoints :: (MonadIO m, CellRendererTextK o) => o -> Double -> m ()+setCellRendererTextSizePoints obj val = liftIO $ setObjectPropertyDouble obj "size-points" val++constructCellRendererTextSizePoints :: Double -> IO ([Char], GValue)+constructCellRendererTextSizePoints val = constructObjectPropertyDouble "size-points" val++data CellRendererTextSizePointsPropertyInfo+instance AttrInfo CellRendererTextSizePointsPropertyInfo where+    type AttrAllowedOps CellRendererTextSizePointsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextSizePointsPropertyInfo = (~) Double+    type AttrBaseTypeConstraint CellRendererTextSizePointsPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextSizePointsPropertyInfo = Double+    type AttrLabel CellRendererTextSizePointsPropertyInfo = "CellRendererText::size-points"+    attrGet _ = getCellRendererTextSizePoints+    attrSet _ = setCellRendererTextSizePoints+    attrConstruct _ = constructCellRendererTextSizePoints++-- VVV Prop "size-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextSizeSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextSizeSet obj = liftIO $ getObjectPropertyBool obj "size-set"++setCellRendererTextSizeSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextSizeSet obj val = liftIO $ setObjectPropertyBool obj "size-set" val++constructCellRendererTextSizeSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextSizeSet val = constructObjectPropertyBool "size-set" val++data CellRendererTextSizeSetPropertyInfo+instance AttrInfo CellRendererTextSizeSetPropertyInfo where+    type AttrAllowedOps CellRendererTextSizeSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextSizeSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextSizeSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextSizeSetPropertyInfo = Bool+    type AttrLabel CellRendererTextSizeSetPropertyInfo = "CellRendererText::size-set"+    attrGet _ = getCellRendererTextSizeSet+    attrSet _ = setCellRendererTextSizeSet+    attrConstruct _ = constructCellRendererTextSizeSet++-- VVV Prop "stretch"+   -- Type: TInterface "Pango" "Stretch"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStretch :: (MonadIO m, CellRendererTextK o) => o -> m Pango.Stretch+getCellRendererTextStretch obj = liftIO $ getObjectPropertyEnum obj "stretch"++setCellRendererTextStretch :: (MonadIO m, CellRendererTextK o) => o -> Pango.Stretch -> m ()+setCellRendererTextStretch obj val = liftIO $ setObjectPropertyEnum obj "stretch" val++constructCellRendererTextStretch :: Pango.Stretch -> IO ([Char], GValue)+constructCellRendererTextStretch val = constructObjectPropertyEnum "stretch" val++data CellRendererTextStretchPropertyInfo+instance AttrInfo CellRendererTextStretchPropertyInfo where+    type AttrAllowedOps CellRendererTextStretchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStretchPropertyInfo = (~) Pango.Stretch+    type AttrBaseTypeConstraint CellRendererTextStretchPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStretchPropertyInfo = Pango.Stretch+    type AttrLabel CellRendererTextStretchPropertyInfo = "CellRendererText::stretch"+    attrGet _ = getCellRendererTextStretch+    attrSet _ = setCellRendererTextStretch+    attrConstruct _ = constructCellRendererTextStretch++-- VVV Prop "stretch-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStretchSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextStretchSet obj = liftIO $ getObjectPropertyBool obj "stretch-set"++setCellRendererTextStretchSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextStretchSet obj val = liftIO $ setObjectPropertyBool obj "stretch-set" val++constructCellRendererTextStretchSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextStretchSet val = constructObjectPropertyBool "stretch-set" val++data CellRendererTextStretchSetPropertyInfo+instance AttrInfo CellRendererTextStretchSetPropertyInfo where+    type AttrAllowedOps CellRendererTextStretchSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStretchSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextStretchSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStretchSetPropertyInfo = Bool+    type AttrLabel CellRendererTextStretchSetPropertyInfo = "CellRendererText::stretch-set"+    attrGet _ = getCellRendererTextStretchSet+    attrSet _ = setCellRendererTextStretchSet+    attrConstruct _ = constructCellRendererTextStretchSet++-- VVV Prop "strikethrough"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStrikethrough :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextStrikethrough obj = liftIO $ getObjectPropertyBool obj "strikethrough"++setCellRendererTextStrikethrough :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextStrikethrough obj val = liftIO $ setObjectPropertyBool obj "strikethrough" val++constructCellRendererTextStrikethrough :: Bool -> IO ([Char], GValue)+constructCellRendererTextStrikethrough val = constructObjectPropertyBool "strikethrough" val++data CellRendererTextStrikethroughPropertyInfo+instance AttrInfo CellRendererTextStrikethroughPropertyInfo where+    type AttrAllowedOps CellRendererTextStrikethroughPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStrikethroughPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextStrikethroughPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStrikethroughPropertyInfo = Bool+    type AttrLabel CellRendererTextStrikethroughPropertyInfo = "CellRendererText::strikethrough"+    attrGet _ = getCellRendererTextStrikethrough+    attrSet _ = setCellRendererTextStrikethrough+    attrConstruct _ = constructCellRendererTextStrikethrough++-- VVV Prop "strikethrough-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStrikethroughSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextStrikethroughSet obj = liftIO $ getObjectPropertyBool obj "strikethrough-set"++setCellRendererTextStrikethroughSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextStrikethroughSet obj val = liftIO $ setObjectPropertyBool obj "strikethrough-set" val++constructCellRendererTextStrikethroughSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextStrikethroughSet val = constructObjectPropertyBool "strikethrough-set" val++data CellRendererTextStrikethroughSetPropertyInfo+instance AttrInfo CellRendererTextStrikethroughSetPropertyInfo where+    type AttrAllowedOps CellRendererTextStrikethroughSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStrikethroughSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextStrikethroughSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStrikethroughSetPropertyInfo = Bool+    type AttrLabel CellRendererTextStrikethroughSetPropertyInfo = "CellRendererText::strikethrough-set"+    attrGet _ = getCellRendererTextStrikethroughSet+    attrSet _ = setCellRendererTextStrikethroughSet+    attrConstruct _ = constructCellRendererTextStrikethroughSet++-- VVV Prop "style"+   -- Type: TInterface "Pango" "Style"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStyle :: (MonadIO m, CellRendererTextK o) => o -> m Pango.Style+getCellRendererTextStyle obj = liftIO $ getObjectPropertyEnum obj "style"++setCellRendererTextStyle :: (MonadIO m, CellRendererTextK o) => o -> Pango.Style -> m ()+setCellRendererTextStyle obj val = liftIO $ setObjectPropertyEnum obj "style" val++constructCellRendererTextStyle :: Pango.Style -> IO ([Char], GValue)+constructCellRendererTextStyle val = constructObjectPropertyEnum "style" val++data CellRendererTextStylePropertyInfo+instance AttrInfo CellRendererTextStylePropertyInfo where+    type AttrAllowedOps CellRendererTextStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStylePropertyInfo = (~) Pango.Style+    type AttrBaseTypeConstraint CellRendererTextStylePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStylePropertyInfo = Pango.Style+    type AttrLabel CellRendererTextStylePropertyInfo = "CellRendererText::style"+    attrGet _ = getCellRendererTextStyle+    attrSet _ = setCellRendererTextStyle+    attrConstruct _ = constructCellRendererTextStyle++-- VVV Prop "style-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextStyleSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextStyleSet obj = liftIO $ getObjectPropertyBool obj "style-set"++setCellRendererTextStyleSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextStyleSet obj val = liftIO $ setObjectPropertyBool obj "style-set" val++constructCellRendererTextStyleSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextStyleSet val = constructObjectPropertyBool "style-set" val++data CellRendererTextStyleSetPropertyInfo+instance AttrInfo CellRendererTextStyleSetPropertyInfo where+    type AttrAllowedOps CellRendererTextStyleSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextStyleSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextStyleSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextStyleSetPropertyInfo = Bool+    type AttrLabel CellRendererTextStyleSetPropertyInfo = "CellRendererText::style-set"+    attrGet _ = getCellRendererTextStyleSet+    attrSet _ = setCellRendererTextStyleSet+    attrConstruct _ = constructCellRendererTextStyleSet++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextText :: (MonadIO m, CellRendererTextK o) => o -> m T.Text+getCellRendererTextText obj = liftIO $ getObjectPropertyString obj "text"++setCellRendererTextText :: (MonadIO m, CellRendererTextK o) => o -> T.Text -> m ()+setCellRendererTextText obj val = liftIO $ setObjectPropertyString obj "text" val++constructCellRendererTextText :: T.Text -> IO ([Char], GValue)+constructCellRendererTextText val = constructObjectPropertyString "text" val++data CellRendererTextTextPropertyInfo+instance AttrInfo CellRendererTextTextPropertyInfo where+    type AttrAllowedOps CellRendererTextTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellRendererTextTextPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextTextPropertyInfo = T.Text+    type AttrLabel CellRendererTextTextPropertyInfo = "CellRendererText::text"+    attrGet _ = getCellRendererTextText+    attrSet _ = setCellRendererTextText+    attrConstruct _ = constructCellRendererTextText++-- VVV Prop "underline"+   -- Type: TInterface "Pango" "Underline"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextUnderline :: (MonadIO m, CellRendererTextK o) => o -> m Pango.Underline+getCellRendererTextUnderline obj = liftIO $ getObjectPropertyEnum obj "underline"++setCellRendererTextUnderline :: (MonadIO m, CellRendererTextK o) => o -> Pango.Underline -> m ()+setCellRendererTextUnderline obj val = liftIO $ setObjectPropertyEnum obj "underline" val++constructCellRendererTextUnderline :: Pango.Underline -> IO ([Char], GValue)+constructCellRendererTextUnderline val = constructObjectPropertyEnum "underline" val++data CellRendererTextUnderlinePropertyInfo+instance AttrInfo CellRendererTextUnderlinePropertyInfo where+    type AttrAllowedOps CellRendererTextUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextUnderlinePropertyInfo = (~) Pango.Underline+    type AttrBaseTypeConstraint CellRendererTextUnderlinePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextUnderlinePropertyInfo = Pango.Underline+    type AttrLabel CellRendererTextUnderlinePropertyInfo = "CellRendererText::underline"+    attrGet _ = getCellRendererTextUnderline+    attrSet _ = setCellRendererTextUnderline+    attrConstruct _ = constructCellRendererTextUnderline++-- VVV Prop "underline-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextUnderlineSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextUnderlineSet obj = liftIO $ getObjectPropertyBool obj "underline-set"++setCellRendererTextUnderlineSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextUnderlineSet obj val = liftIO $ setObjectPropertyBool obj "underline-set" val++constructCellRendererTextUnderlineSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextUnderlineSet val = constructObjectPropertyBool "underline-set" val++data CellRendererTextUnderlineSetPropertyInfo+instance AttrInfo CellRendererTextUnderlineSetPropertyInfo where+    type AttrAllowedOps CellRendererTextUnderlineSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextUnderlineSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextUnderlineSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextUnderlineSetPropertyInfo = Bool+    type AttrLabel CellRendererTextUnderlineSetPropertyInfo = "CellRendererText::underline-set"+    attrGet _ = getCellRendererTextUnderlineSet+    attrSet _ = setCellRendererTextUnderlineSet+    attrConstruct _ = constructCellRendererTextUnderlineSet++-- VVV Prop "variant"+   -- Type: TInterface "Pango" "Variant"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextVariant :: (MonadIO m, CellRendererTextK o) => o -> m Pango.Variant+getCellRendererTextVariant obj = liftIO $ getObjectPropertyEnum obj "variant"++setCellRendererTextVariant :: (MonadIO m, CellRendererTextK o) => o -> Pango.Variant -> m ()+setCellRendererTextVariant obj val = liftIO $ setObjectPropertyEnum obj "variant" val++constructCellRendererTextVariant :: Pango.Variant -> IO ([Char], GValue)+constructCellRendererTextVariant val = constructObjectPropertyEnum "variant" val++data CellRendererTextVariantPropertyInfo+instance AttrInfo CellRendererTextVariantPropertyInfo where+    type AttrAllowedOps CellRendererTextVariantPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextVariantPropertyInfo = (~) Pango.Variant+    type AttrBaseTypeConstraint CellRendererTextVariantPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextVariantPropertyInfo = Pango.Variant+    type AttrLabel CellRendererTextVariantPropertyInfo = "CellRendererText::variant"+    attrGet _ = getCellRendererTextVariant+    attrSet _ = setCellRendererTextVariant+    attrConstruct _ = constructCellRendererTextVariant++-- VVV Prop "variant-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextVariantSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextVariantSet obj = liftIO $ getObjectPropertyBool obj "variant-set"++setCellRendererTextVariantSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextVariantSet obj val = liftIO $ setObjectPropertyBool obj "variant-set" val++constructCellRendererTextVariantSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextVariantSet val = constructObjectPropertyBool "variant-set" val++data CellRendererTextVariantSetPropertyInfo+instance AttrInfo CellRendererTextVariantSetPropertyInfo where+    type AttrAllowedOps CellRendererTextVariantSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextVariantSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextVariantSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextVariantSetPropertyInfo = Bool+    type AttrLabel CellRendererTextVariantSetPropertyInfo = "CellRendererText::variant-set"+    attrGet _ = getCellRendererTextVariantSet+    attrSet _ = setCellRendererTextVariantSet+    attrConstruct _ = constructCellRendererTextVariantSet++-- VVV Prop "weight"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextWeight :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextWeight obj = liftIO $ getObjectPropertyCInt obj "weight"++setCellRendererTextWeight :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextWeight obj val = liftIO $ setObjectPropertyCInt obj "weight" val++constructCellRendererTextWeight :: Int32 -> IO ([Char], GValue)+constructCellRendererTextWeight val = constructObjectPropertyCInt "weight" val++data CellRendererTextWeightPropertyInfo+instance AttrInfo CellRendererTextWeightPropertyInfo where+    type AttrAllowedOps CellRendererTextWeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextWeightPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextWeightPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextWeightPropertyInfo = Int32+    type AttrLabel CellRendererTextWeightPropertyInfo = "CellRendererText::weight"+    attrGet _ = getCellRendererTextWeight+    attrSet _ = setCellRendererTextWeight+    attrConstruct _ = constructCellRendererTextWeight++-- VVV Prop "weight-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextWeightSet :: (MonadIO m, CellRendererTextK o) => o -> m Bool+getCellRendererTextWeightSet obj = liftIO $ getObjectPropertyBool obj "weight-set"++setCellRendererTextWeightSet :: (MonadIO m, CellRendererTextK o) => o -> Bool -> m ()+setCellRendererTextWeightSet obj val = liftIO $ setObjectPropertyBool obj "weight-set" val++constructCellRendererTextWeightSet :: Bool -> IO ([Char], GValue)+constructCellRendererTextWeightSet val = constructObjectPropertyBool "weight-set" val++data CellRendererTextWeightSetPropertyInfo+instance AttrInfo CellRendererTextWeightSetPropertyInfo where+    type AttrAllowedOps CellRendererTextWeightSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextWeightSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererTextWeightSetPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextWeightSetPropertyInfo = Bool+    type AttrLabel CellRendererTextWeightSetPropertyInfo = "CellRendererText::weight-set"+    attrGet _ = getCellRendererTextWeightSet+    attrSet _ = setCellRendererTextWeightSet+    attrConstruct _ = constructCellRendererTextWeightSet++-- VVV Prop "width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextWidthChars :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextWidthChars obj = liftIO $ getObjectPropertyCInt obj "width-chars"++setCellRendererTextWidthChars :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextWidthChars obj val = liftIO $ setObjectPropertyCInt obj "width-chars" val++constructCellRendererTextWidthChars :: Int32 -> IO ([Char], GValue)+constructCellRendererTextWidthChars val = constructObjectPropertyCInt "width-chars" val++data CellRendererTextWidthCharsPropertyInfo+instance AttrInfo CellRendererTextWidthCharsPropertyInfo where+    type AttrAllowedOps CellRendererTextWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextWidthCharsPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextWidthCharsPropertyInfo = Int32+    type AttrLabel CellRendererTextWidthCharsPropertyInfo = "CellRendererText::width-chars"+    attrGet _ = getCellRendererTextWidthChars+    attrSet _ = setCellRendererTextWidthChars+    attrConstruct _ = constructCellRendererTextWidthChars++-- VVV Prop "wrap-mode"+   -- Type: TInterface "Pango" "WrapMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextWrapMode :: (MonadIO m, CellRendererTextK o) => o -> m Pango.WrapMode+getCellRendererTextWrapMode obj = liftIO $ getObjectPropertyEnum obj "wrap-mode"++setCellRendererTextWrapMode :: (MonadIO m, CellRendererTextK o) => o -> Pango.WrapMode -> m ()+setCellRendererTextWrapMode obj val = liftIO $ setObjectPropertyEnum obj "wrap-mode" val++constructCellRendererTextWrapMode :: Pango.WrapMode -> IO ([Char], GValue)+constructCellRendererTextWrapMode val = constructObjectPropertyEnum "wrap-mode" val++data CellRendererTextWrapModePropertyInfo+instance AttrInfo CellRendererTextWrapModePropertyInfo where+    type AttrAllowedOps CellRendererTextWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextWrapModePropertyInfo = (~) Pango.WrapMode+    type AttrBaseTypeConstraint CellRendererTextWrapModePropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextWrapModePropertyInfo = Pango.WrapMode+    type AttrLabel CellRendererTextWrapModePropertyInfo = "CellRendererText::wrap-mode"+    attrGet _ = getCellRendererTextWrapMode+    attrSet _ = setCellRendererTextWrapMode+    attrConstruct _ = constructCellRendererTextWrapMode++-- VVV Prop "wrap-width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererTextWrapWidth :: (MonadIO m, CellRendererTextK o) => o -> m Int32+getCellRendererTextWrapWidth obj = liftIO $ getObjectPropertyCInt obj "wrap-width"++setCellRendererTextWrapWidth :: (MonadIO m, CellRendererTextK o) => o -> Int32 -> m ()+setCellRendererTextWrapWidth obj val = liftIO $ setObjectPropertyCInt obj "wrap-width" val++constructCellRendererTextWrapWidth :: Int32 -> IO ([Char], GValue)+constructCellRendererTextWrapWidth val = constructObjectPropertyCInt "wrap-width" val++data CellRendererTextWrapWidthPropertyInfo+instance AttrInfo CellRendererTextWrapWidthPropertyInfo where+    type AttrAllowedOps CellRendererTextWrapWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererTextWrapWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererTextWrapWidthPropertyInfo = CellRendererTextK+    type AttrGetType CellRendererTextWrapWidthPropertyInfo = Int32+    type AttrLabel CellRendererTextWrapWidthPropertyInfo = "CellRendererText::wrap-width"+    attrGet _ = getCellRendererTextWrapWidth+    attrSet _ = setCellRendererTextWrapWidth+    attrConstruct _ = constructCellRendererTextWrapWidth++type instance AttributeList CellRendererText = CellRendererTextAttributeList+type CellRendererTextAttributeList = ('[ '("align-set", CellRendererTextAlignSetPropertyInfo), '("alignment", CellRendererTextAlignmentPropertyInfo), '("attributes", CellRendererTextAttributesPropertyInfo), '("background", CellRendererTextBackgroundPropertyInfo), '("background-gdk", CellRendererTextBackgroundGdkPropertyInfo), '("background-rgba", CellRendererTextBackgroundRgbaPropertyInfo), '("background-set", CellRendererTextBackgroundSetPropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editable", CellRendererTextEditablePropertyInfo), '("editable-set", CellRendererTextEditableSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("ellipsize", CellRendererTextEllipsizePropertyInfo), '("ellipsize-set", CellRendererTextEllipsizeSetPropertyInfo), '("family", CellRendererTextFamilyPropertyInfo), '("family-set", CellRendererTextFamilySetPropertyInfo), '("font", CellRendererTextFontPropertyInfo), '("font-desc", CellRendererTextFontDescPropertyInfo), '("foreground", CellRendererTextForegroundPropertyInfo), '("foreground-gdk", CellRendererTextForegroundGdkPropertyInfo), '("foreground-rgba", CellRendererTextForegroundRgbaPropertyInfo), '("foreground-set", CellRendererTextForegroundSetPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("language", CellRendererTextLanguagePropertyInfo), '("language-set", CellRendererTextLanguageSetPropertyInfo), '("markup", CellRendererTextMarkupPropertyInfo), '("max-width-chars", CellRendererTextMaxWidthCharsPropertyInfo), '("mode", CellRendererModePropertyInfo), '("placeholder-text", CellRendererTextPlaceholderTextPropertyInfo), '("rise", CellRendererTextRisePropertyInfo), '("rise-set", CellRendererTextRiseSetPropertyInfo), '("scale", CellRendererTextScalePropertyInfo), '("scale-set", CellRendererTextScaleSetPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("single-paragraph-mode", CellRendererTextSingleParagraphModePropertyInfo), '("size", CellRendererTextSizePropertyInfo), '("size-points", CellRendererTextSizePointsPropertyInfo), '("size-set", CellRendererTextSizeSetPropertyInfo), '("stretch", CellRendererTextStretchPropertyInfo), '("stretch-set", CellRendererTextStretchSetPropertyInfo), '("strikethrough", CellRendererTextStrikethroughPropertyInfo), '("strikethrough-set", CellRendererTextStrikethroughSetPropertyInfo), '("style", CellRendererTextStylePropertyInfo), '("style-set", CellRendererTextStyleSetPropertyInfo), '("text", CellRendererTextTextPropertyInfo), '("underline", CellRendererTextUnderlinePropertyInfo), '("underline-set", CellRendererTextUnderlineSetPropertyInfo), '("variant", CellRendererTextVariantPropertyInfo), '("variant-set", CellRendererTextVariantSetPropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("weight", CellRendererTextWeightPropertyInfo), '("weight-set", CellRendererTextWeightSetPropertyInfo), '("width", CellRendererWidthPropertyInfo), '("width-chars", CellRendererTextWidthCharsPropertyInfo), '("wrap-mode", CellRendererTextWrapModePropertyInfo), '("wrap-width", CellRendererTextWrapWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++data CellRendererTextEditedSignalInfo+instance SignalInfo CellRendererTextEditedSignalInfo where+    type HaskellCallbackType CellRendererTextEditedSignalInfo = CellRendererTextEditedCallback+    connectSignal _ = connectCellRendererTextEdited++type instance SignalList CellRendererText = CellRendererTextSignalList+type CellRendererTextSignalList = ('[ '("edited", CellRendererTextEditedSignalInfo), '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererText::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererText"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_text_new" gtk_cell_renderer_text_new :: +    IO (Ptr CellRendererText)+++cellRendererTextNew ::+    (MonadIO m) =>+    m CellRendererText+cellRendererTextNew  = liftIO $ do+    result <- gtk_cell_renderer_text_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_text_new" result+    result' <- (newObject CellRendererText) result+    return result'++-- method CellRendererText::set_fixed_height_from_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_of_rows", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_of_rows", 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 "gtk_cell_renderer_text_set_fixed_height_from_font" gtk_cell_renderer_text_set_fixed_height_from_font :: +    Ptr CellRendererText ->                 -- _obj : TInterface "Gtk" "CellRendererText"+    Int32 ->                                -- number_of_rows : TBasicType TInt32+    IO ()+++cellRendererTextSetFixedHeightFromFont ::+    (MonadIO m, CellRendererTextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- number_of_rows+    m ()+cellRendererTextSetFixedHeightFromFont _obj number_of_rows = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_cell_renderer_text_set_fixed_height_from_font _obj' number_of_rows+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellRendererText.hs-boot view
@@ -0,0 +1,62 @@+module GI.Gtk.Objects.CellRendererText where++import Prelude ()+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 CellRendererText = CellRendererText (ForeignPtr CellRendererText)+instance GObject CellRendererText where+class GObject o => CellRendererTextK o+instance (GObject o, IsDescendantOf CellRendererText o) => CellRendererTextK o+data CellRendererTextAlignSetPropertyInfo+data CellRendererTextAlignmentPropertyInfo+data CellRendererTextAttributesPropertyInfo+data CellRendererTextBackgroundPropertyInfo+data CellRendererTextBackgroundGdkPropertyInfo+data CellRendererTextBackgroundRgbaPropertyInfo+data CellRendererTextBackgroundSetPropertyInfo+data CellRendererTextEditablePropertyInfo+data CellRendererTextEditableSetPropertyInfo+data CellRendererTextEllipsizePropertyInfo+data CellRendererTextEllipsizeSetPropertyInfo+data CellRendererTextFamilyPropertyInfo+data CellRendererTextFamilySetPropertyInfo+data CellRendererTextFontPropertyInfo+data CellRendererTextFontDescPropertyInfo+data CellRendererTextForegroundPropertyInfo+data CellRendererTextForegroundGdkPropertyInfo+data CellRendererTextForegroundRgbaPropertyInfo+data CellRendererTextForegroundSetPropertyInfo+data CellRendererTextLanguagePropertyInfo+data CellRendererTextLanguageSetPropertyInfo+data CellRendererTextMarkupPropertyInfo+data CellRendererTextMaxWidthCharsPropertyInfo+data CellRendererTextPlaceholderTextPropertyInfo+data CellRendererTextRisePropertyInfo+data CellRendererTextRiseSetPropertyInfo+data CellRendererTextScalePropertyInfo+data CellRendererTextScaleSetPropertyInfo+data CellRendererTextSingleParagraphModePropertyInfo+data CellRendererTextSizePropertyInfo+data CellRendererTextSizePointsPropertyInfo+data CellRendererTextSizeSetPropertyInfo+data CellRendererTextStretchPropertyInfo+data CellRendererTextStretchSetPropertyInfo+data CellRendererTextStrikethroughPropertyInfo+data CellRendererTextStrikethroughSetPropertyInfo+data CellRendererTextStylePropertyInfo+data CellRendererTextStyleSetPropertyInfo+data CellRendererTextTextPropertyInfo+data CellRendererTextUnderlinePropertyInfo+data CellRendererTextUnderlineSetPropertyInfo+data CellRendererTextVariantPropertyInfo+data CellRendererTextVariantSetPropertyInfo+data CellRendererTextWeightPropertyInfo+data CellRendererTextWeightSetPropertyInfo+data CellRendererTextWidthCharsPropertyInfo+data CellRendererTextWrapModePropertyInfo+data CellRendererTextWrapWidthPropertyInfo+data CellRendererTextEditedSignalInfo
+ GI/Gtk/Objects/CellRendererToggle.hs view
@@ -0,0 +1,487 @@++{- |+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.Gtk.Objects.CellRendererToggle+    ( ++-- * Exported types+    CellRendererToggle(..)                  ,+    CellRendererToggleK                     ,+    toCellRendererToggle                    ,+    noCellRendererToggle                    ,+++ -- * Methods+-- ** cellRendererToggleGetActivatable+    cellRendererToggleGetActivatable        ,+++-- ** cellRendererToggleGetActive+    cellRendererToggleGetActive             ,+++-- ** cellRendererToggleGetRadio+    cellRendererToggleGetRadio              ,+++-- ** cellRendererToggleNew+    cellRendererToggleNew                   ,+++-- ** cellRendererToggleSetActivatable+    cellRendererToggleSetActivatable        ,+++-- ** cellRendererToggleSetActive+    cellRendererToggleSetActive             ,+++-- ** cellRendererToggleSetRadio+    cellRendererToggleSetRadio              ,+++++ -- * Properties+-- ** Activatable+    CellRendererToggleActivatablePropertyInfo,+    constructCellRendererToggleActivatable  ,+    getCellRendererToggleActivatable        ,+    setCellRendererToggleActivatable        ,+++-- ** Active+    CellRendererToggleActivePropertyInfo    ,+    constructCellRendererToggleActive       ,+    getCellRendererToggleActive             ,+    setCellRendererToggleActive             ,+++-- ** Inconsistent+    CellRendererToggleInconsistentPropertyInfo,+    constructCellRendererToggleInconsistent ,+    getCellRendererToggleInconsistent       ,+    setCellRendererToggleInconsistent       ,+++-- ** IndicatorSize+    CellRendererToggleIndicatorSizePropertyInfo,+    constructCellRendererToggleIndicatorSize,+    getCellRendererToggleIndicatorSize      ,+    setCellRendererToggleIndicatorSize      ,+++-- ** Radio+    CellRendererToggleRadioPropertyInfo     ,+    constructCellRendererToggleRadio        ,+    getCellRendererToggleRadio              ,+    setCellRendererToggleRadio              ,+++++ -- * Signals+-- ** Toggled+    CellRendererToggleToggledCallback       ,+    CellRendererToggleToggledCallbackC      ,+    CellRendererToggleToggledSignalInfo     ,+    afterCellRendererToggleToggled          ,+    cellRendererToggleToggledCallbackWrapper,+    cellRendererToggleToggledClosure        ,+    mkCellRendererToggleToggledCallback     ,+    noCellRendererToggleToggledCallback     ,+    onCellRendererToggleToggled             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype CellRendererToggle = CellRendererToggle (ForeignPtr CellRendererToggle)+foreign import ccall "gtk_cell_renderer_toggle_get_type"+    c_gtk_cell_renderer_toggle_get_type :: IO GType++type instance ParentTypes CellRendererToggle = CellRendererToggleParentTypes+type CellRendererToggleParentTypes = '[CellRenderer, GObject.Object]++instance GObject CellRendererToggle where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_renderer_toggle_get_type+    ++class GObject o => CellRendererToggleK o+instance (GObject o, IsDescendantOf CellRendererToggle o) => CellRendererToggleK o++toCellRendererToggle :: CellRendererToggleK o => o -> IO CellRendererToggle+toCellRendererToggle = unsafeCastTo CellRendererToggle++noCellRendererToggle :: Maybe CellRendererToggle+noCellRendererToggle = Nothing++-- signal CellRendererToggle::toggled+type CellRendererToggleToggledCallback =+    T.Text ->+    IO ()++noCellRendererToggleToggledCallback :: Maybe CellRendererToggleToggledCallback+noCellRendererToggleToggledCallback = Nothing++type CellRendererToggleToggledCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCellRendererToggleToggledCallback :: CellRendererToggleToggledCallbackC -> IO (FunPtr CellRendererToggleToggledCallbackC)++cellRendererToggleToggledClosure :: CellRendererToggleToggledCallback -> IO Closure+cellRendererToggleToggledClosure cb = newCClosure =<< mkCellRendererToggleToggledCallback wrapped+    where wrapped = cellRendererToggleToggledCallbackWrapper cb++cellRendererToggleToggledCallbackWrapper ::+    CellRendererToggleToggledCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+cellRendererToggleToggledCallbackWrapper _cb _ path _ = do+    path' <- cstringToText path+    _cb  path'++onCellRendererToggleToggled :: (GObject a, MonadIO m) => a -> CellRendererToggleToggledCallback -> m SignalHandlerId+onCellRendererToggleToggled obj cb = liftIO $ connectCellRendererToggleToggled obj cb SignalConnectBefore+afterCellRendererToggleToggled :: (GObject a, MonadIO m) => a -> CellRendererToggleToggledCallback -> m SignalHandlerId+afterCellRendererToggleToggled obj cb = connectCellRendererToggleToggled obj cb SignalConnectAfter++connectCellRendererToggleToggled :: (GObject a, MonadIO m) =>+                                    a -> CellRendererToggleToggledCallback -> SignalConnectMode -> m SignalHandlerId+connectCellRendererToggleToggled obj cb after = liftIO $ do+    cb' <- mkCellRendererToggleToggledCallback (cellRendererToggleToggledCallbackWrapper cb)+    connectSignalFunPtr obj "toggled" cb' after++-- VVV Prop "activatable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererToggleActivatable :: (MonadIO m, CellRendererToggleK o) => o -> m Bool+getCellRendererToggleActivatable obj = liftIO $ getObjectPropertyBool obj "activatable"++setCellRendererToggleActivatable :: (MonadIO m, CellRendererToggleK o) => o -> Bool -> m ()+setCellRendererToggleActivatable obj val = liftIO $ setObjectPropertyBool obj "activatable" val++constructCellRendererToggleActivatable :: Bool -> IO ([Char], GValue)+constructCellRendererToggleActivatable val = constructObjectPropertyBool "activatable" val++data CellRendererToggleActivatablePropertyInfo+instance AttrInfo CellRendererToggleActivatablePropertyInfo where+    type AttrAllowedOps CellRendererToggleActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererToggleActivatablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererToggleActivatablePropertyInfo = CellRendererToggleK+    type AttrGetType CellRendererToggleActivatablePropertyInfo = Bool+    type AttrLabel CellRendererToggleActivatablePropertyInfo = "CellRendererToggle::activatable"+    attrGet _ = getCellRendererToggleActivatable+    attrSet _ = setCellRendererToggleActivatable+    attrConstruct _ = constructCellRendererToggleActivatable++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererToggleActive :: (MonadIO m, CellRendererToggleK o) => o -> m Bool+getCellRendererToggleActive obj = liftIO $ getObjectPropertyBool obj "active"++setCellRendererToggleActive :: (MonadIO m, CellRendererToggleK o) => o -> Bool -> m ()+setCellRendererToggleActive obj val = liftIO $ setObjectPropertyBool obj "active" val++constructCellRendererToggleActive :: Bool -> IO ([Char], GValue)+constructCellRendererToggleActive val = constructObjectPropertyBool "active" val++data CellRendererToggleActivePropertyInfo+instance AttrInfo CellRendererToggleActivePropertyInfo where+    type AttrAllowedOps CellRendererToggleActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererToggleActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererToggleActivePropertyInfo = CellRendererToggleK+    type AttrGetType CellRendererToggleActivePropertyInfo = Bool+    type AttrLabel CellRendererToggleActivePropertyInfo = "CellRendererToggle::active"+    attrGet _ = getCellRendererToggleActive+    attrSet _ = setCellRendererToggleActive+    attrConstruct _ = constructCellRendererToggleActive++-- VVV Prop "inconsistent"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererToggleInconsistent :: (MonadIO m, CellRendererToggleK o) => o -> m Bool+getCellRendererToggleInconsistent obj = liftIO $ getObjectPropertyBool obj "inconsistent"++setCellRendererToggleInconsistent :: (MonadIO m, CellRendererToggleK o) => o -> Bool -> m ()+setCellRendererToggleInconsistent obj val = liftIO $ setObjectPropertyBool obj "inconsistent" val++constructCellRendererToggleInconsistent :: Bool -> IO ([Char], GValue)+constructCellRendererToggleInconsistent val = constructObjectPropertyBool "inconsistent" val++data CellRendererToggleInconsistentPropertyInfo+instance AttrInfo CellRendererToggleInconsistentPropertyInfo where+    type AttrAllowedOps CellRendererToggleInconsistentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererToggleInconsistentPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererToggleInconsistentPropertyInfo = CellRendererToggleK+    type AttrGetType CellRendererToggleInconsistentPropertyInfo = Bool+    type AttrLabel CellRendererToggleInconsistentPropertyInfo = "CellRendererToggle::inconsistent"+    attrGet _ = getCellRendererToggleInconsistent+    attrSet _ = setCellRendererToggleInconsistent+    attrConstruct _ = constructCellRendererToggleInconsistent++-- VVV Prop "indicator-size"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererToggleIndicatorSize :: (MonadIO m, CellRendererToggleK o) => o -> m Int32+getCellRendererToggleIndicatorSize obj = liftIO $ getObjectPropertyCInt obj "indicator-size"++setCellRendererToggleIndicatorSize :: (MonadIO m, CellRendererToggleK o) => o -> Int32 -> m ()+setCellRendererToggleIndicatorSize obj val = liftIO $ setObjectPropertyCInt obj "indicator-size" val++constructCellRendererToggleIndicatorSize :: Int32 -> IO ([Char], GValue)+constructCellRendererToggleIndicatorSize val = constructObjectPropertyCInt "indicator-size" val++data CellRendererToggleIndicatorSizePropertyInfo+instance AttrInfo CellRendererToggleIndicatorSizePropertyInfo where+    type AttrAllowedOps CellRendererToggleIndicatorSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererToggleIndicatorSizePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint CellRendererToggleIndicatorSizePropertyInfo = CellRendererToggleK+    type AttrGetType CellRendererToggleIndicatorSizePropertyInfo = Int32+    type AttrLabel CellRendererToggleIndicatorSizePropertyInfo = "CellRendererToggle::indicator-size"+    attrGet _ = getCellRendererToggleIndicatorSize+    attrSet _ = setCellRendererToggleIndicatorSize+    attrConstruct _ = constructCellRendererToggleIndicatorSize++-- VVV Prop "radio"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellRendererToggleRadio :: (MonadIO m, CellRendererToggleK o) => o -> m Bool+getCellRendererToggleRadio obj = liftIO $ getObjectPropertyBool obj "radio"++setCellRendererToggleRadio :: (MonadIO m, CellRendererToggleK o) => o -> Bool -> m ()+setCellRendererToggleRadio obj val = liftIO $ setObjectPropertyBool obj "radio" val++constructCellRendererToggleRadio :: Bool -> IO ([Char], GValue)+constructCellRendererToggleRadio val = constructObjectPropertyBool "radio" val++data CellRendererToggleRadioPropertyInfo+instance AttrInfo CellRendererToggleRadioPropertyInfo where+    type AttrAllowedOps CellRendererToggleRadioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellRendererToggleRadioPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellRendererToggleRadioPropertyInfo = CellRendererToggleK+    type AttrGetType CellRendererToggleRadioPropertyInfo = Bool+    type AttrLabel CellRendererToggleRadioPropertyInfo = "CellRendererToggle::radio"+    attrGet _ = getCellRendererToggleRadio+    attrSet _ = setCellRendererToggleRadio+    attrConstruct _ = constructCellRendererToggleRadio++type instance AttributeList CellRendererToggle = CellRendererToggleAttributeList+type CellRendererToggleAttributeList = ('[ '("activatable", CellRendererToggleActivatablePropertyInfo), '("active", CellRendererToggleActivePropertyInfo), '("cell-background", CellRendererCellBackgroundPropertyInfo), '("cell-background-gdk", CellRendererCellBackgroundGdkPropertyInfo), '("cell-background-rgba", CellRendererCellBackgroundRgbaPropertyInfo), '("cell-background-set", CellRendererCellBackgroundSetPropertyInfo), '("editing", CellRendererEditingPropertyInfo), '("height", CellRendererHeightPropertyInfo), '("inconsistent", CellRendererToggleInconsistentPropertyInfo), '("indicator-size", CellRendererToggleIndicatorSizePropertyInfo), '("is-expanded", CellRendererIsExpandedPropertyInfo), '("is-expander", CellRendererIsExpanderPropertyInfo), '("mode", CellRendererModePropertyInfo), '("radio", CellRendererToggleRadioPropertyInfo), '("sensitive", CellRendererSensitivePropertyInfo), '("visible", CellRendererVisiblePropertyInfo), '("width", CellRendererWidthPropertyInfo), '("xalign", CellRendererXalignPropertyInfo), '("xpad", CellRendererXpadPropertyInfo), '("yalign", CellRendererYalignPropertyInfo), '("ypad", CellRendererYpadPropertyInfo)] :: [(Symbol, *)])++data CellRendererToggleToggledSignalInfo+instance SignalInfo CellRendererToggleToggledSignalInfo where+    type HaskellCallbackType CellRendererToggleToggledSignalInfo = CellRendererToggleToggledCallback+    connectSignal _ = connectCellRendererToggleToggled++type instance SignalList CellRendererToggle = CellRendererToggleSignalList+type CellRendererToggleSignalList = ('[ '("editing-canceled", CellRendererEditingCanceledSignalInfo), '("editing-started", CellRendererEditingStartedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("toggled", CellRendererToggleToggledSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellRendererToggle::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellRendererToggle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_toggle_new" gtk_cell_renderer_toggle_new :: +    IO (Ptr CellRendererToggle)+++cellRendererToggleNew ::+    (MonadIO m) =>+    m CellRendererToggle+cellRendererToggleNew  = liftIO $ do+    result <- gtk_cell_renderer_toggle_new+    checkUnexpectedReturnNULL "gtk_cell_renderer_toggle_new" result+    result' <- (newObject CellRendererToggle) result+    return result'++-- method CellRendererToggle::get_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_toggle_get_activatable" gtk_cell_renderer_toggle_get_activatable :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    IO CInt+++cellRendererToggleGetActivatable ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererToggleGetActivatable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_toggle_get_activatable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRendererToggle::get_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_toggle_get_active" gtk_cell_renderer_toggle_get_active :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    IO CInt+++cellRendererToggleGetActive ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererToggleGetActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_toggle_get_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRendererToggle::get_radio+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_renderer_toggle_get_radio" gtk_cell_renderer_toggle_get_radio :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    IO CInt+++cellRendererToggleGetRadio ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    m Bool+cellRendererToggleGetRadio _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_renderer_toggle_get_radio _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellRendererToggle::set_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_cell_renderer_toggle_set_activatable" gtk_cell_renderer_toggle_set_activatable :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++cellRendererToggleSetActivatable ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+cellRendererToggleSetActivatable _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_cell_renderer_toggle_set_activatable _obj' setting'+    touchManagedPtr _obj+    return ()++-- method CellRendererToggle::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_cell_renderer_toggle_set_active" gtk_cell_renderer_toggle_set_active :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++cellRendererToggleSetActive ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+cellRendererToggleSetActive _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_cell_renderer_toggle_set_active _obj' setting'+    touchManagedPtr _obj+    return ()++-- method CellRendererToggle::set_radio+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "radio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellRendererToggle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "radio", 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 "gtk_cell_renderer_toggle_set_radio" gtk_cell_renderer_toggle_set_radio :: +    Ptr CellRendererToggle ->               -- _obj : TInterface "Gtk" "CellRendererToggle"+    CInt ->                                 -- radio : TBasicType TBoolean+    IO ()+++cellRendererToggleSetRadio ::+    (MonadIO m, CellRendererToggleK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- radio+    m ()+cellRendererToggleSetRadio _obj radio = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let radio' = (fromIntegral . fromEnum) radio+    gtk_cell_renderer_toggle_set_radio _obj' radio'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CellRendererToggle.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.CellRendererToggle where++import Prelude ()+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 CellRendererToggle = CellRendererToggle (ForeignPtr CellRendererToggle)+instance GObject CellRendererToggle where+class GObject o => CellRendererToggleK o+instance (GObject o, IsDescendantOf CellRendererToggle o) => CellRendererToggleK o+data CellRendererToggleActivatablePropertyInfo+data CellRendererToggleActivePropertyInfo+data CellRendererToggleInconsistentPropertyInfo+data CellRendererToggleIndicatorSizePropertyInfo+data CellRendererToggleRadioPropertyInfo+data CellRendererToggleToggledSignalInfo
+ GI/Gtk/Objects/CellView.hs view
@@ -0,0 +1,836 @@++{- |+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.Gtk.Objects.CellView+    ( ++-- * Exported types+    CellView(..)                            ,+    CellViewK                               ,+    toCellView                              ,+    noCellView                              ,+++ -- * Methods+-- ** cellViewGetDisplayedRow+    cellViewGetDisplayedRow                 ,+++-- ** cellViewGetDrawSensitive+    cellViewGetDrawSensitive                ,+++-- ** cellViewGetFitModel+    cellViewGetFitModel                     ,+++-- ** cellViewGetModel+    cellViewGetModel                        ,+++-- ** cellViewGetSizeOfRow+    cellViewGetSizeOfRow                    ,+++-- ** cellViewNew+    cellViewNew                             ,+++-- ** cellViewNewWithContext+    cellViewNewWithContext                  ,+++-- ** cellViewNewWithMarkup+    cellViewNewWithMarkup                   ,+++-- ** cellViewNewWithPixbuf+    cellViewNewWithPixbuf                   ,+++-- ** cellViewNewWithText+    cellViewNewWithText                     ,+++-- ** cellViewSetBackgroundColor+    cellViewSetBackgroundColor              ,+++-- ** cellViewSetBackgroundRgba+    cellViewSetBackgroundRgba               ,+++-- ** cellViewSetDisplayedRow+    cellViewSetDisplayedRow                 ,+++-- ** cellViewSetDrawSensitive+    cellViewSetDrawSensitive                ,+++-- ** cellViewSetFitModel+    cellViewSetFitModel                     ,+++-- ** cellViewSetModel+    cellViewSetModel                        ,+++++ -- * Properties+-- ** Background+    CellViewBackgroundPropertyInfo          ,+    constructCellViewBackground             ,+    setCellViewBackground                   ,+++-- ** BackgroundGdk+    CellViewBackgroundGdkPropertyInfo       ,+    constructCellViewBackgroundGdk          ,+    getCellViewBackgroundGdk                ,+    setCellViewBackgroundGdk                ,+++-- ** BackgroundRgba+    CellViewBackgroundRgbaPropertyInfo      ,+    constructCellViewBackgroundRgba         ,+    getCellViewBackgroundRgba               ,+    setCellViewBackgroundRgba               ,+++-- ** BackgroundSet+    CellViewBackgroundSetPropertyInfo       ,+    constructCellViewBackgroundSet          ,+    getCellViewBackgroundSet                ,+    setCellViewBackgroundSet                ,+++-- ** CellArea+    CellViewCellAreaPropertyInfo            ,+    constructCellViewCellArea               ,+    getCellViewCellArea                     ,+++-- ** CellAreaContext+    CellViewCellAreaContextPropertyInfo     ,+    constructCellViewCellAreaContext        ,+    getCellViewCellAreaContext              ,+++-- ** DrawSensitive+    CellViewDrawSensitivePropertyInfo       ,+    constructCellViewDrawSensitive          ,+    getCellViewDrawSensitive                ,+    setCellViewDrawSensitive                ,+++-- ** FitModel+    CellViewFitModelPropertyInfo            ,+    constructCellViewFitModel               ,+    getCellViewFitModel                     ,+    setCellViewFitModel                     ,+++-- ** Model+    CellViewModelPropertyInfo               ,+    constructCellViewModel                  ,+    getCellViewModel                        ,+    setCellViewModel                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf++newtype CellView = CellView (ForeignPtr CellView)+foreign import ccall "gtk_cell_view_get_type"+    c_gtk_cell_view_get_type :: IO GType++type instance ParentTypes CellView = CellViewParentTypes+type CellViewParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable, CellLayout, Orientable]++instance GObject CellView where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_cell_view_get_type+    ++class GObject o => CellViewK o+instance (GObject o, IsDescendantOf CellView o) => CellViewK o++toCellView :: CellViewK o => o -> IO CellView+toCellView = unsafeCastTo CellView++noCellView :: Maybe CellView+noCellView = Nothing++-- VVV Prop "background"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setCellViewBackground :: (MonadIO m, CellViewK o) => o -> T.Text -> m ()+setCellViewBackground obj val = liftIO $ setObjectPropertyString obj "background" val++constructCellViewBackground :: T.Text -> IO ([Char], GValue)+constructCellViewBackground val = constructObjectPropertyString "background" val++data CellViewBackgroundPropertyInfo+instance AttrInfo CellViewBackgroundPropertyInfo where+    type AttrAllowedOps CellViewBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint CellViewBackgroundPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint CellViewBackgroundPropertyInfo = CellViewK+    type AttrGetType CellViewBackgroundPropertyInfo = ()+    type AttrLabel CellViewBackgroundPropertyInfo = "CellView::background"+    attrGet _ = undefined+    attrSet _ = setCellViewBackground+    attrConstruct _ = constructCellViewBackground++-- VVV Prop "background-gdk"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewBackgroundGdk :: (MonadIO m, CellViewK o) => o -> m Gdk.Color+getCellViewBackgroundGdk obj = liftIO $ getObjectPropertyBoxed obj "background-gdk" Gdk.Color++setCellViewBackgroundGdk :: (MonadIO m, CellViewK o) => o -> Gdk.Color -> m ()+setCellViewBackgroundGdk obj val = liftIO $ setObjectPropertyBoxed obj "background-gdk" val++constructCellViewBackgroundGdk :: Gdk.Color -> IO ([Char], GValue)+constructCellViewBackgroundGdk val = constructObjectPropertyBoxed "background-gdk" val++data CellViewBackgroundGdkPropertyInfo+instance AttrInfo CellViewBackgroundGdkPropertyInfo where+    type AttrAllowedOps CellViewBackgroundGdkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewBackgroundGdkPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint CellViewBackgroundGdkPropertyInfo = CellViewK+    type AttrGetType CellViewBackgroundGdkPropertyInfo = Gdk.Color+    type AttrLabel CellViewBackgroundGdkPropertyInfo = "CellView::background-gdk"+    attrGet _ = getCellViewBackgroundGdk+    attrSet _ = setCellViewBackgroundGdk+    attrConstruct _ = constructCellViewBackgroundGdk++-- VVV Prop "background-rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewBackgroundRgba :: (MonadIO m, CellViewK o) => o -> m Gdk.RGBA+getCellViewBackgroundRgba obj = liftIO $ getObjectPropertyBoxed obj "background-rgba" Gdk.RGBA++setCellViewBackgroundRgba :: (MonadIO m, CellViewK o) => o -> Gdk.RGBA -> m ()+setCellViewBackgroundRgba obj val = liftIO $ setObjectPropertyBoxed obj "background-rgba" val++constructCellViewBackgroundRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructCellViewBackgroundRgba val = constructObjectPropertyBoxed "background-rgba" val++data CellViewBackgroundRgbaPropertyInfo+instance AttrInfo CellViewBackgroundRgbaPropertyInfo where+    type AttrAllowedOps CellViewBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewBackgroundRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint CellViewBackgroundRgbaPropertyInfo = CellViewK+    type AttrGetType CellViewBackgroundRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel CellViewBackgroundRgbaPropertyInfo = "CellView::background-rgba"+    attrGet _ = getCellViewBackgroundRgba+    attrSet _ = setCellViewBackgroundRgba+    attrConstruct _ = constructCellViewBackgroundRgba++-- VVV Prop "background-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewBackgroundSet :: (MonadIO m, CellViewK o) => o -> m Bool+getCellViewBackgroundSet obj = liftIO $ getObjectPropertyBool obj "background-set"++setCellViewBackgroundSet :: (MonadIO m, CellViewK o) => o -> Bool -> m ()+setCellViewBackgroundSet obj val = liftIO $ setObjectPropertyBool obj "background-set" val++constructCellViewBackgroundSet :: Bool -> IO ([Char], GValue)+constructCellViewBackgroundSet val = constructObjectPropertyBool "background-set" val++data CellViewBackgroundSetPropertyInfo+instance AttrInfo CellViewBackgroundSetPropertyInfo where+    type AttrAllowedOps CellViewBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewBackgroundSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellViewBackgroundSetPropertyInfo = CellViewK+    type AttrGetType CellViewBackgroundSetPropertyInfo = Bool+    type AttrLabel CellViewBackgroundSetPropertyInfo = "CellView::background-set"+    attrGet _ = getCellViewBackgroundSet+    attrSet _ = setCellViewBackgroundSet+    attrConstruct _ = constructCellViewBackgroundSet++-- VVV Prop "cell-area"+   -- Type: TInterface "Gtk" "CellArea"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getCellViewCellArea :: (MonadIO m, CellViewK o) => o -> m CellArea+getCellViewCellArea obj = liftIO $ getObjectPropertyObject obj "cell-area" CellArea++constructCellViewCellArea :: (CellAreaK a) => a -> IO ([Char], GValue)+constructCellViewCellArea val = constructObjectPropertyObject "cell-area" val++data CellViewCellAreaPropertyInfo+instance AttrInfo CellViewCellAreaPropertyInfo where+    type AttrAllowedOps CellViewCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewCellAreaPropertyInfo = CellAreaK+    type AttrBaseTypeConstraint CellViewCellAreaPropertyInfo = CellViewK+    type AttrGetType CellViewCellAreaPropertyInfo = CellArea+    type AttrLabel CellViewCellAreaPropertyInfo = "CellView::cell-area"+    attrGet _ = getCellViewCellArea+    attrSet _ = undefined+    attrConstruct _ = constructCellViewCellArea++-- VVV Prop "cell-area-context"+   -- Type: TInterface "Gtk" "CellAreaContext"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getCellViewCellAreaContext :: (MonadIO m, CellViewK o) => o -> m CellAreaContext+getCellViewCellAreaContext obj = liftIO $ getObjectPropertyObject obj "cell-area-context" CellAreaContext++constructCellViewCellAreaContext :: (CellAreaContextK a) => a -> IO ([Char], GValue)+constructCellViewCellAreaContext val = constructObjectPropertyObject "cell-area-context" val++data CellViewCellAreaContextPropertyInfo+instance AttrInfo CellViewCellAreaContextPropertyInfo where+    type AttrAllowedOps CellViewCellAreaContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewCellAreaContextPropertyInfo = CellAreaContextK+    type AttrBaseTypeConstraint CellViewCellAreaContextPropertyInfo = CellViewK+    type AttrGetType CellViewCellAreaContextPropertyInfo = CellAreaContext+    type AttrLabel CellViewCellAreaContextPropertyInfo = "CellView::cell-area-context"+    attrGet _ = getCellViewCellAreaContext+    attrSet _ = undefined+    attrConstruct _ = constructCellViewCellAreaContext++-- VVV Prop "draw-sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewDrawSensitive :: (MonadIO m, CellViewK o) => o -> m Bool+getCellViewDrawSensitive obj = liftIO $ getObjectPropertyBool obj "draw-sensitive"++setCellViewDrawSensitive :: (MonadIO m, CellViewK o) => o -> Bool -> m ()+setCellViewDrawSensitive obj val = liftIO $ setObjectPropertyBool obj "draw-sensitive" val++constructCellViewDrawSensitive :: Bool -> IO ([Char], GValue)+constructCellViewDrawSensitive val = constructObjectPropertyBool "draw-sensitive" val++data CellViewDrawSensitivePropertyInfo+instance AttrInfo CellViewDrawSensitivePropertyInfo where+    type AttrAllowedOps CellViewDrawSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewDrawSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellViewDrawSensitivePropertyInfo = CellViewK+    type AttrGetType CellViewDrawSensitivePropertyInfo = Bool+    type AttrLabel CellViewDrawSensitivePropertyInfo = "CellView::draw-sensitive"+    attrGet _ = getCellViewDrawSensitive+    attrSet _ = setCellViewDrawSensitive+    attrConstruct _ = constructCellViewDrawSensitive++-- VVV Prop "fit-model"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewFitModel :: (MonadIO m, CellViewK o) => o -> m Bool+getCellViewFitModel obj = liftIO $ getObjectPropertyBool obj "fit-model"++setCellViewFitModel :: (MonadIO m, CellViewK o) => o -> Bool -> m ()+setCellViewFitModel obj val = liftIO $ setObjectPropertyBool obj "fit-model" val++constructCellViewFitModel :: Bool -> IO ([Char], GValue)+constructCellViewFitModel val = constructObjectPropertyBool "fit-model" val++data CellViewFitModelPropertyInfo+instance AttrInfo CellViewFitModelPropertyInfo where+    type AttrAllowedOps CellViewFitModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewFitModelPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CellViewFitModelPropertyInfo = CellViewK+    type AttrGetType CellViewFitModelPropertyInfo = Bool+    type AttrLabel CellViewFitModelPropertyInfo = "CellView::fit-model"+    attrGet _ = getCellViewFitModel+    attrSet _ = setCellViewFitModel+    attrConstruct _ = constructCellViewFitModel++-- VVV Prop "model"+   -- Type: TInterface "Gtk" "TreeModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getCellViewModel :: (MonadIO m, CellViewK o) => o -> m TreeModel+getCellViewModel obj = liftIO $ getObjectPropertyObject obj "model" TreeModel++setCellViewModel :: (MonadIO m, CellViewK o, TreeModelK a) => o -> a -> m ()+setCellViewModel obj val = liftIO $ setObjectPropertyObject obj "model" val++constructCellViewModel :: (TreeModelK a) => a -> IO ([Char], GValue)+constructCellViewModel val = constructObjectPropertyObject "model" val++data CellViewModelPropertyInfo+instance AttrInfo CellViewModelPropertyInfo where+    type AttrAllowedOps CellViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CellViewModelPropertyInfo = TreeModelK+    type AttrBaseTypeConstraint CellViewModelPropertyInfo = CellViewK+    type AttrGetType CellViewModelPropertyInfo = TreeModel+    type AttrLabel CellViewModelPropertyInfo = "CellView::model"+    attrGet _ = getCellViewModel+    attrSet _ = setCellViewModel+    attrConstruct _ = constructCellViewModel++type instance AttributeList CellView = CellViewAttributeList+type CellViewAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("background", CellViewBackgroundPropertyInfo), '("background-gdk", CellViewBackgroundGdkPropertyInfo), '("background-rgba", CellViewBackgroundRgbaPropertyInfo), '("background-set", CellViewBackgroundSetPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cell-area", CellViewCellAreaPropertyInfo), '("cell-area-context", CellViewCellAreaContextPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-sensitive", CellViewDrawSensitivePropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("fit-model", CellViewFitModelPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("model", CellViewModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CellView = CellViewSignalList+type CellViewSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CellView::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CellView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_new" gtk_cell_view_new :: +    IO (Ptr CellView)+++cellViewNew ::+    (MonadIO m) =>+    m CellView+cellViewNew  = liftIO $ do+    result <- gtk_cell_view_new+    checkUnexpectedReturnNULL "gtk_cell_view_new" result+    result' <- (newObject CellView) result+    return result'++-- method CellView::new_with_context+-- method type : Constructor+-- Args : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "CellAreaContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_new_with_context" gtk_cell_view_new_with_context :: +    Ptr CellArea ->                         -- area : TInterface "Gtk" "CellArea"+    Ptr CellAreaContext ->                  -- context : TInterface "Gtk" "CellAreaContext"+    IO (Ptr CellView)+++cellViewNewWithContext ::+    (MonadIO m, CellAreaK a, CellAreaContextK b) =>+    a ->                                    -- area+    b ->                                    -- context+    m CellView+cellViewNewWithContext area context = liftIO $ do+    let area' = unsafeManagedPtrCastPtr area+    let context' = unsafeManagedPtrCastPtr context+    result <- gtk_cell_view_new_with_context area' context'+    checkUnexpectedReturnNULL "gtk_cell_view_new_with_context" result+    result' <- (newObject CellView) result+    touchManagedPtr area+    touchManagedPtr context+    return result'++-- method CellView::new_with_markup+-- method type : Constructor+-- Args : [Arg {argName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_new_with_markup" gtk_cell_view_new_with_markup :: +    CString ->                              -- markup : TBasicType TUTF8+    IO (Ptr CellView)+++cellViewNewWithMarkup ::+    (MonadIO m) =>+    T.Text ->                               -- markup+    m CellView+cellViewNewWithMarkup markup = liftIO $ do+    markup' <- textToCString markup+    result <- gtk_cell_view_new_with_markup markup'+    checkUnexpectedReturnNULL "gtk_cell_view_new_with_markup" result+    result' <- (newObject CellView) result+    freeMem markup'+    return result'++-- method CellView::new_with_pixbuf+-- method type : Constructor+-- Args : [Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_new_with_pixbuf" gtk_cell_view_new_with_pixbuf :: +    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO (Ptr CellView)+++cellViewNewWithPixbuf ::+    (MonadIO m, GdkPixbuf.PixbufK a) =>+    a ->                                    -- pixbuf+    m CellView+cellViewNewWithPixbuf pixbuf = liftIO $ do+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    result <- gtk_cell_view_new_with_pixbuf pixbuf'+    checkUnexpectedReturnNULL "gtk_cell_view_new_with_pixbuf" result+    result' <- (newObject CellView) result+    touchManagedPtr pixbuf+    return result'++-- method CellView::new_with_text+-- method type : Constructor+-- Args : [Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CellView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_new_with_text" gtk_cell_view_new_with_text :: +    CString ->                              -- text : TBasicType TUTF8+    IO (Ptr CellView)+++cellViewNewWithText ::+    (MonadIO m) =>+    T.Text ->                               -- text+    m CellView+cellViewNewWithText text = liftIO $ do+    text' <- textToCString text+    result <- gtk_cell_view_new_with_text text'+    checkUnexpectedReturnNULL "gtk_cell_view_new_with_text" result+    result' <- (newObject CellView) result+    freeMem text'+    return result'++-- method CellView::get_displayed_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreePath"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_get_displayed_row" gtk_cell_view_get_displayed_row :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    IO (Ptr TreePath)+++cellViewGetDisplayedRow ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    m TreePath+cellViewGetDisplayedRow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_view_get_displayed_row _obj'+    checkUnexpectedReturnNULL "gtk_cell_view_get_displayed_row" result+    result' <- (wrapBoxed TreePath) result+    touchManagedPtr _obj+    return result'++-- method CellView::get_draw_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_get_draw_sensitive" gtk_cell_view_get_draw_sensitive :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    IO CInt+++cellViewGetDrawSensitive ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    m Bool+cellViewGetDrawSensitive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_view_get_draw_sensitive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellView::get_fit_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_get_fit_model" gtk_cell_view_get_fit_model :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    IO CInt+++cellViewGetFitModel ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    m Bool+cellViewGetFitModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_view_get_fit_model _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CellView::get_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_get_model" gtk_cell_view_get_model :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    IO (Ptr TreeModel)+++cellViewGetModel ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    m TreeModel+cellViewGetModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_cell_view_get_model _obj'+    checkUnexpectedReturnNULL "gtk_cell_view_get_model" result+    result' <- (newObject TreeModel) result+    touchManagedPtr _obj+    return result'++-- method CellView::get_size_of_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "requisition", argType = TInterface "Gtk" "Requisition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_get_size_of_row" gtk_cell_view_get_size_of_row :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr Requisition ->                      -- requisition : TInterface "Gtk" "Requisition"+    IO CInt++{-# DEPRECATED cellViewGetSizeOfRow ["(Since version 3.0)","Combo box formerly used this to calculate the","sizes for cellviews, now you can achieve this by either using","the #GtkCellView:fit-model property or by setting the currently","displayed row of the #GtkCellView and using gtk_widget_get_preferred_size()."]#-}+cellViewGetSizeOfRow ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m (Bool,Requisition)+cellViewGetSizeOfRow _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    requisition <- callocBoxedBytes 8 :: IO (Ptr Requisition)+    result <- gtk_cell_view_get_size_of_row _obj' path' requisition+    let result' = (/= 0) result+    requisition' <- (wrapBoxed Requisition) requisition+    touchManagedPtr _obj+    touchManagedPtr path+    return (result', requisition')++-- method CellView::set_background_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_set_background_color" gtk_cell_view_set_background_color :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED cellViewSetBackgroundColor ["(Since version 3.4)","Use gtk_cell_view_set_background_rgba() instead."]#-}+cellViewSetBackgroundColor ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    Gdk.Color ->                            -- color+    m ()+cellViewSetBackgroundColor _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let color' = unsafeManagedPtrGetPtr color+    gtk_cell_view_set_background_color _obj' color'+    touchManagedPtr _obj+    touchManagedPtr color+    return ()++-- method CellView::set_background_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_set_background_rgba" gtk_cell_view_set_background_rgba :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO ()+++cellViewSetBackgroundRgba ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- rgba+    m ()+cellViewSetBackgroundRgba _obj rgba = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let rgba' = unsafeManagedPtrGetPtr rgba+    gtk_cell_view_set_background_rgba _obj' rgba'+    touchManagedPtr _obj+    touchManagedPtr rgba+    return ()++-- method CellView::set_displayed_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_set_displayed_row" gtk_cell_view_set_displayed_row :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++cellViewSetDisplayedRow ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    Maybe (TreePath) ->                     -- path+    m ()+cellViewSetDisplayedRow _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePath <- case path of+        Nothing -> return nullPtr+        Just jPath -> do+            let jPath' = unsafeManagedPtrGetPtr jPath+            return jPath'+    gtk_cell_view_set_displayed_row _obj' maybePath+    touchManagedPtr _obj+    whenJust path touchManagedPtr+    return ()++-- method CellView::set_draw_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_sensitive", 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 "gtk_cell_view_set_draw_sensitive" gtk_cell_view_set_draw_sensitive :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    CInt ->                                 -- draw_sensitive : TBasicType TBoolean+    IO ()+++cellViewSetDrawSensitive ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- draw_sensitive+    m ()+cellViewSetDrawSensitive _obj draw_sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let draw_sensitive' = (fromIntegral . fromEnum) draw_sensitive+    gtk_cell_view_set_draw_sensitive _obj' draw_sensitive'+    touchManagedPtr _obj+    return ()++-- method CellView::set_fit_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fit_model", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fit_model", 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 "gtk_cell_view_set_fit_model" gtk_cell_view_set_fit_model :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    CInt ->                                 -- fit_model : TBasicType TBoolean+    IO ()+++cellViewSetFitModel ::+    (MonadIO m, CellViewK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- fit_model+    m ()+cellViewSetFitModel _obj fit_model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fit_model' = (fromIntegral . fromEnum) fit_model+    gtk_cell_view_set_fit_model _obj' fit_model'+    touchManagedPtr _obj+    return ()++-- method CellView::set_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CellView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_cell_view_set_model" gtk_cell_view_set_model :: +    Ptr CellView ->                         -- _obj : TInterface "Gtk" "CellView"+    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO ()+++cellViewSetModel ::+    (MonadIO m, CellViewK a, TreeModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    m ()+cellViewSetModel _obj model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    gtk_cell_view_set_model _obj' maybeModel+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    return ()++
+ GI/Gtk/Objects/CellView.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gtk.Objects.CellView where++import Prelude ()+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 CellView = CellView (ForeignPtr CellView)+instance GObject CellView where+class GObject o => CellViewK o+instance (GObject o, IsDescendantOf CellView o) => CellViewK o+data CellViewBackgroundPropertyInfo+data CellViewBackgroundGdkPropertyInfo+data CellViewBackgroundRgbaPropertyInfo+data CellViewBackgroundSetPropertyInfo+data CellViewCellAreaPropertyInfo+data CellViewCellAreaContextPropertyInfo+data CellViewDrawSensitivePropertyInfo+data CellViewFitModelPropertyInfo+data CellViewModelPropertyInfo
+ GI/Gtk/Objects/CheckButton.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.Gtk.Objects.CheckButton+    ( ++-- * Exported types+    CheckButton(..)                         ,+    CheckButtonK                            ,+    toCheckButton                           ,+    noCheckButton                           ,+++ -- * Methods+-- ** checkButtonNew+    checkButtonNew                          ,+++-- ** checkButtonNewWithLabel+    checkButtonNewWithLabel                 ,+++-- ** checkButtonNewWithMnemonic+    checkButtonNewWithMnemonic              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype CheckButton = CheckButton (ForeignPtr CheckButton)+foreign import ccall "gtk_check_button_get_type"+    c_gtk_check_button_get_type :: IO GType++type instance ParentTypes CheckButton = CheckButtonParentTypes+type CheckButtonParentTypes = '[ToggleButton, Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject CheckButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_check_button_get_type+    ++class GObject o => CheckButtonK o+instance (GObject o, IsDescendantOf CheckButton o) => CheckButtonK o++toCheckButton :: CheckButtonK o => o -> IO CheckButton+toCheckButton = unsafeCastTo CheckButton++noCheckButton :: Maybe CheckButton+noCheckButton = Nothing++type instance AttributeList CheckButton = CheckButtonAttributeList+type CheckButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", ToggleButtonActivePropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-indicator", ToggleButtonDrawIndicatorPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("inconsistent", ToggleButtonInconsistentPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CheckButton = CheckButtonSignalList+type CheckButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggled", ToggleButtonToggledSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CheckButton::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CheckButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_button_new" gtk_check_button_new :: +    IO (Ptr CheckButton)+++checkButtonNew ::+    (MonadIO m) =>+    m CheckButton+checkButtonNew  = liftIO $ do+    result <- gtk_check_button_new+    checkUnexpectedReturnNULL "gtk_check_button_new" result+    result' <- (newObject CheckButton) result+    return result'++-- method CheckButton::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CheckButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_button_new_with_label" gtk_check_button_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr CheckButton)+++checkButtonNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m CheckButton+checkButtonNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- gtk_check_button_new_with_label label'+    checkUnexpectedReturnNULL "gtk_check_button_new_with_label" result+    result' <- (newObject CheckButton) result+    freeMem label'+    return result'++-- method CheckButton::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CheckButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_button_new_with_mnemonic" gtk_check_button_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr CheckButton)+++checkButtonNewWithMnemonic ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m CheckButton+checkButtonNewWithMnemonic label = liftIO $ do+    label' <- textToCString label+    result <- gtk_check_button_new_with_mnemonic label'+    checkUnexpectedReturnNULL "gtk_check_button_new_with_mnemonic" result+    result' <- (newObject CheckButton) result+    freeMem label'+    return result'++
+ GI/Gtk/Objects/CheckButton.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.CheckButton where++import Prelude ()+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 CheckButton = CheckButton (ForeignPtr CheckButton)+instance GObject CheckButton where+class GObject o => CheckButtonK o+instance (GObject o, IsDescendantOf CheckButton o) => CheckButtonK o
+ GI/Gtk/Objects/CheckMenuItem.hs view
@@ -0,0 +1,510 @@++{- |+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.Gtk.Objects.CheckMenuItem+    ( ++-- * Exported types+    CheckMenuItem(..)                       ,+    CheckMenuItemK                          ,+    toCheckMenuItem                         ,+    noCheckMenuItem                         ,+++ -- * Methods+-- ** checkMenuItemGetActive+    checkMenuItemGetActive                  ,+++-- ** checkMenuItemGetDrawAsRadio+    checkMenuItemGetDrawAsRadio             ,+++-- ** checkMenuItemGetInconsistent+    checkMenuItemGetInconsistent            ,+++-- ** checkMenuItemNew+    checkMenuItemNew                        ,+++-- ** checkMenuItemNewWithLabel+    checkMenuItemNewWithLabel               ,+++-- ** checkMenuItemNewWithMnemonic+    checkMenuItemNewWithMnemonic            ,+++-- ** checkMenuItemSetActive+    checkMenuItemSetActive                  ,+++-- ** checkMenuItemSetDrawAsRadio+    checkMenuItemSetDrawAsRadio             ,+++-- ** checkMenuItemSetInconsistent+    checkMenuItemSetInconsistent            ,+++-- ** checkMenuItemToggled+    checkMenuItemToggled                    ,+++++ -- * Properties+-- ** Active+    CheckMenuItemActivePropertyInfo         ,+    constructCheckMenuItemActive            ,+    getCheckMenuItemActive                  ,+    setCheckMenuItemActive                  ,+++-- ** DrawAsRadio+    CheckMenuItemDrawAsRadioPropertyInfo    ,+    constructCheckMenuItemDrawAsRadio       ,+    getCheckMenuItemDrawAsRadio             ,+    setCheckMenuItemDrawAsRadio             ,+++-- ** Inconsistent+    CheckMenuItemInconsistentPropertyInfo   ,+    constructCheckMenuItemInconsistent      ,+    getCheckMenuItemInconsistent            ,+    setCheckMenuItemInconsistent            ,+++++ -- * Signals+-- ** Toggled+    CheckMenuItemToggledCallback            ,+    CheckMenuItemToggledCallbackC           ,+    CheckMenuItemToggledSignalInfo          ,+    afterCheckMenuItemToggled               ,+    checkMenuItemToggledCallbackWrapper     ,+    checkMenuItemToggledClosure             ,+    mkCheckMenuItemToggledCallback          ,+    noCheckMenuItemToggledCallback          ,+    onCheckMenuItemToggled                  ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype CheckMenuItem = CheckMenuItem (ForeignPtr CheckMenuItem)+foreign import ccall "gtk_check_menu_item_get_type"+    c_gtk_check_menu_item_get_type :: IO GType++type instance ParentTypes CheckMenuItem = CheckMenuItemParentTypes+type CheckMenuItemParentTypes = '[MenuItem, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject CheckMenuItem where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_check_menu_item_get_type+    ++class GObject o => CheckMenuItemK o+instance (GObject o, IsDescendantOf CheckMenuItem o) => CheckMenuItemK o++toCheckMenuItem :: CheckMenuItemK o => o -> IO CheckMenuItem+toCheckMenuItem = unsafeCastTo CheckMenuItem++noCheckMenuItem :: Maybe CheckMenuItem+noCheckMenuItem = Nothing++-- signal CheckMenuItem::toggled+type CheckMenuItemToggledCallback =+    IO ()++noCheckMenuItemToggledCallback :: Maybe CheckMenuItemToggledCallback+noCheckMenuItemToggledCallback = Nothing++type CheckMenuItemToggledCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCheckMenuItemToggledCallback :: CheckMenuItemToggledCallbackC -> IO (FunPtr CheckMenuItemToggledCallbackC)++checkMenuItemToggledClosure :: CheckMenuItemToggledCallback -> IO Closure+checkMenuItemToggledClosure cb = newCClosure =<< mkCheckMenuItemToggledCallback wrapped+    where wrapped = checkMenuItemToggledCallbackWrapper cb++checkMenuItemToggledCallbackWrapper ::+    CheckMenuItemToggledCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+checkMenuItemToggledCallbackWrapper _cb _ _ = do+    _cb ++onCheckMenuItemToggled :: (GObject a, MonadIO m) => a -> CheckMenuItemToggledCallback -> m SignalHandlerId+onCheckMenuItemToggled obj cb = liftIO $ connectCheckMenuItemToggled obj cb SignalConnectBefore+afterCheckMenuItemToggled :: (GObject a, MonadIO m) => a -> CheckMenuItemToggledCallback -> m SignalHandlerId+afterCheckMenuItemToggled obj cb = connectCheckMenuItemToggled obj cb SignalConnectAfter++connectCheckMenuItemToggled :: (GObject a, MonadIO m) =>+                               a -> CheckMenuItemToggledCallback -> SignalConnectMode -> m SignalHandlerId+connectCheckMenuItemToggled obj cb after = liftIO $ do+    cb' <- mkCheckMenuItemToggledCallback (checkMenuItemToggledCallbackWrapper cb)+    connectSignalFunPtr obj "toggled" cb' after++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCheckMenuItemActive :: (MonadIO m, CheckMenuItemK o) => o -> m Bool+getCheckMenuItemActive obj = liftIO $ getObjectPropertyBool obj "active"++setCheckMenuItemActive :: (MonadIO m, CheckMenuItemK o) => o -> Bool -> m ()+setCheckMenuItemActive obj val = liftIO $ setObjectPropertyBool obj "active" val++constructCheckMenuItemActive :: Bool -> IO ([Char], GValue)+constructCheckMenuItemActive val = constructObjectPropertyBool "active" val++data CheckMenuItemActivePropertyInfo+instance AttrInfo CheckMenuItemActivePropertyInfo where+    type AttrAllowedOps CheckMenuItemActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CheckMenuItemActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CheckMenuItemActivePropertyInfo = CheckMenuItemK+    type AttrGetType CheckMenuItemActivePropertyInfo = Bool+    type AttrLabel CheckMenuItemActivePropertyInfo = "CheckMenuItem::active"+    attrGet _ = getCheckMenuItemActive+    attrSet _ = setCheckMenuItemActive+    attrConstruct _ = constructCheckMenuItemActive++-- VVV Prop "draw-as-radio"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCheckMenuItemDrawAsRadio :: (MonadIO m, CheckMenuItemK o) => o -> m Bool+getCheckMenuItemDrawAsRadio obj = liftIO $ getObjectPropertyBool obj "draw-as-radio"++setCheckMenuItemDrawAsRadio :: (MonadIO m, CheckMenuItemK o) => o -> Bool -> m ()+setCheckMenuItemDrawAsRadio obj val = liftIO $ setObjectPropertyBool obj "draw-as-radio" val++constructCheckMenuItemDrawAsRadio :: Bool -> IO ([Char], GValue)+constructCheckMenuItemDrawAsRadio val = constructObjectPropertyBool "draw-as-radio" val++data CheckMenuItemDrawAsRadioPropertyInfo+instance AttrInfo CheckMenuItemDrawAsRadioPropertyInfo where+    type AttrAllowedOps CheckMenuItemDrawAsRadioPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CheckMenuItemDrawAsRadioPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CheckMenuItemDrawAsRadioPropertyInfo = CheckMenuItemK+    type AttrGetType CheckMenuItemDrawAsRadioPropertyInfo = Bool+    type AttrLabel CheckMenuItemDrawAsRadioPropertyInfo = "CheckMenuItem::draw-as-radio"+    attrGet _ = getCheckMenuItemDrawAsRadio+    attrSet _ = setCheckMenuItemDrawAsRadio+    attrConstruct _ = constructCheckMenuItemDrawAsRadio++-- VVV Prop "inconsistent"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getCheckMenuItemInconsistent :: (MonadIO m, CheckMenuItemK o) => o -> m Bool+getCheckMenuItemInconsistent obj = liftIO $ getObjectPropertyBool obj "inconsistent"++setCheckMenuItemInconsistent :: (MonadIO m, CheckMenuItemK o) => o -> Bool -> m ()+setCheckMenuItemInconsistent obj val = liftIO $ setObjectPropertyBool obj "inconsistent" val++constructCheckMenuItemInconsistent :: Bool -> IO ([Char], GValue)+constructCheckMenuItemInconsistent val = constructObjectPropertyBool "inconsistent" val++data CheckMenuItemInconsistentPropertyInfo+instance AttrInfo CheckMenuItemInconsistentPropertyInfo where+    type AttrAllowedOps CheckMenuItemInconsistentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint CheckMenuItemInconsistentPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint CheckMenuItemInconsistentPropertyInfo = CheckMenuItemK+    type AttrGetType CheckMenuItemInconsistentPropertyInfo = Bool+    type AttrLabel CheckMenuItemInconsistentPropertyInfo = "CheckMenuItem::inconsistent"+    attrGet _ = getCheckMenuItemInconsistent+    attrSet _ = setCheckMenuItemInconsistent+    attrConstruct _ = constructCheckMenuItemInconsistent++type instance AttributeList CheckMenuItem = CheckMenuItemAttributeList+type CheckMenuItemAttributeList = ('[ '("accel-path", MenuItemAccelPathPropertyInfo), '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", CheckMenuItemActivePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-as-radio", CheckMenuItemDrawAsRadioPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inconsistent", CheckMenuItemInconsistentPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", MenuItemLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("right-justified", MenuItemRightJustifiedPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("submenu", MenuItemSubmenuPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-underline", MenuItemUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data CheckMenuItemToggledSignalInfo+instance SignalInfo CheckMenuItemToggledSignalInfo where+    type HaskellCallbackType CheckMenuItemToggledSignalInfo = CheckMenuItemToggledCallback+    connectSignal _ = connectCheckMenuItemToggled++type instance SignalList CheckMenuItem = CheckMenuItemSignalList+type CheckMenuItemSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", MenuItemActivateSignalInfo), '("activate-item", MenuItemActivateItemSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("deselect", MenuItemDeselectSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select", MenuItemSelectSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-size-allocate", MenuItemToggleSizeAllocateSignalInfo), '("toggle-size-request", MenuItemToggleSizeRequestSignalInfo), '("toggled", CheckMenuItemToggledSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CheckMenuItem::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CheckMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_new" gtk_check_menu_item_new :: +    IO (Ptr CheckMenuItem)+++checkMenuItemNew ::+    (MonadIO m) =>+    m CheckMenuItem+checkMenuItemNew  = liftIO $ do+    result <- gtk_check_menu_item_new+    checkUnexpectedReturnNULL "gtk_check_menu_item_new" result+    result' <- (newObject CheckMenuItem) result+    return result'++-- method CheckMenuItem::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CheckMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_new_with_label" gtk_check_menu_item_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr CheckMenuItem)+++checkMenuItemNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m CheckMenuItem+checkMenuItemNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- gtk_check_menu_item_new_with_label label'+    checkUnexpectedReturnNULL "gtk_check_menu_item_new_with_label" result+    result' <- (newObject CheckMenuItem) result+    freeMem label'+    return result'++-- method CheckMenuItem::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CheckMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_new_with_mnemonic" gtk_check_menu_item_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr CheckMenuItem)+++checkMenuItemNewWithMnemonic ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m CheckMenuItem+checkMenuItemNewWithMnemonic label = liftIO $ do+    label' <- textToCString label+    result <- gtk_check_menu_item_new_with_mnemonic label'+    checkUnexpectedReturnNULL "gtk_check_menu_item_new_with_mnemonic" result+    result' <- (newObject CheckMenuItem) result+    freeMem label'+    return result'++-- method CheckMenuItem::get_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_get_active" gtk_check_menu_item_get_active :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    IO CInt+++checkMenuItemGetActive ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    m Bool+checkMenuItemGetActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_check_menu_item_get_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CheckMenuItem::get_draw_as_radio+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_get_draw_as_radio" gtk_check_menu_item_get_draw_as_radio :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    IO CInt+++checkMenuItemGetDrawAsRadio ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    m Bool+checkMenuItemGetDrawAsRadio _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_check_menu_item_get_draw_as_radio _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CheckMenuItem::get_inconsistent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_get_inconsistent" gtk_check_menu_item_get_inconsistent :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    IO CInt+++checkMenuItemGetInconsistent ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    m Bool+checkMenuItemGetInconsistent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_check_menu_item_get_inconsistent _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method CheckMenuItem::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_active", 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 "gtk_check_menu_item_set_active" gtk_check_menu_item_set_active :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    CInt ->                                 -- is_active : TBasicType TBoolean+    IO ()+++checkMenuItemSetActive ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_active+    m ()+checkMenuItemSetActive _obj is_active = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_active' = (fromIntegral . fromEnum) is_active+    gtk_check_menu_item_set_active _obj' is_active'+    touchManagedPtr _obj+    return ()++-- method CheckMenuItem::set_draw_as_radio+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_as_radio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "draw_as_radio", 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 "gtk_check_menu_item_set_draw_as_radio" gtk_check_menu_item_set_draw_as_radio :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    CInt ->                                 -- draw_as_radio : TBasicType TBoolean+    IO ()+++checkMenuItemSetDrawAsRadio ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- draw_as_radio+    m ()+checkMenuItemSetDrawAsRadio _obj draw_as_radio = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let draw_as_radio' = (fromIntegral . fromEnum) draw_as_radio+    gtk_check_menu_item_set_draw_as_radio _obj' draw_as_radio'+    touchManagedPtr _obj+    return ()++-- method CheckMenuItem::set_inconsistent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_check_menu_item_set_inconsistent" gtk_check_menu_item_set_inconsistent :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++checkMenuItemSetInconsistent ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+checkMenuItemSetInconsistent _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_check_menu_item_set_inconsistent _obj' setting'+    touchManagedPtr _obj+    return ()++-- method CheckMenuItem::toggled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CheckMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_check_menu_item_toggled" gtk_check_menu_item_toggled :: +    Ptr CheckMenuItem ->                    -- _obj : TInterface "Gtk" "CheckMenuItem"+    IO ()+++checkMenuItemToggled ::+    (MonadIO m, CheckMenuItemK a) =>+    a ->                                    -- _obj+    m ()+checkMenuItemToggled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_check_menu_item_toggled _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/CheckMenuItem.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.CheckMenuItem where++import Prelude ()+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 CheckMenuItem = CheckMenuItem (ForeignPtr CheckMenuItem)+instance GObject CheckMenuItem where+class GObject o => CheckMenuItemK o+instance (GObject o, IsDescendantOf CheckMenuItem o) => CheckMenuItemK o+data CheckMenuItemActivePropertyInfo+data CheckMenuItemDrawAsRadioPropertyInfo+data CheckMenuItemInconsistentPropertyInfo+data CheckMenuItemToggledSignalInfo
+ GI/Gtk/Objects/CheckMenuItemAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.CheckMenuItemAccessible+    ( ++-- * Exported types+    CheckMenuItemAccessible(..)             ,+    CheckMenuItemAccessibleK                ,+    toCheckMenuItemAccessible               ,+    noCheckMenuItemAccessible               ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype CheckMenuItemAccessible = CheckMenuItemAccessible (ForeignPtr CheckMenuItemAccessible)+foreign import ccall "gtk_check_menu_item_accessible_get_type"+    c_gtk_check_menu_item_accessible_get_type :: IO GType++type instance ParentTypes CheckMenuItemAccessible = CheckMenuItemAccessibleParentTypes+type CheckMenuItemAccessibleParentTypes = '[MenuItemAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Selection]++instance GObject CheckMenuItemAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_check_menu_item_accessible_get_type+    ++class GObject o => CheckMenuItemAccessibleK o+instance (GObject o, IsDescendantOf CheckMenuItemAccessible o) => CheckMenuItemAccessibleK o++toCheckMenuItemAccessible :: CheckMenuItemAccessibleK o => o -> IO CheckMenuItemAccessible+toCheckMenuItemAccessible = unsafeCastTo CheckMenuItemAccessible++noCheckMenuItemAccessible :: Maybe CheckMenuItemAccessible+noCheckMenuItemAccessible = Nothing++type instance AttributeList CheckMenuItemAccessible = CheckMenuItemAccessibleAttributeList+type CheckMenuItemAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList CheckMenuItemAccessible = CheckMenuItemAccessibleSignalList+type CheckMenuItemAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/CheckMenuItemAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.CheckMenuItemAccessible where++import Prelude ()+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 CheckMenuItemAccessible = CheckMenuItemAccessible (ForeignPtr CheckMenuItemAccessible)+instance GObject CheckMenuItemAccessible where+class GObject o => CheckMenuItemAccessibleK o+instance (GObject o, IsDescendantOf CheckMenuItemAccessible o) => CheckMenuItemAccessibleK o
+ GI/Gtk/Objects/Clipboard.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.Gtk.Objects.Clipboard+    ( ++-- * Exported types+    Clipboard(..)                           ,+    ClipboardK                              ,+    toClipboard                             ,+    noClipboard                             ,+++ -- * Methods+-- ** clipboardClear+    clipboardClear                          ,+++-- ** clipboardGet+    clipboardGet                            ,+++-- ** clipboardGetDefault+    clipboardGetDefault                     ,+++-- ** clipboardGetDisplay+    clipboardGetDisplay                     ,+++-- ** clipboardGetForDisplay+    clipboardGetForDisplay                  ,+++-- ** clipboardGetOwner+    clipboardGetOwner                       ,+++-- ** clipboardRequestContents+    clipboardRequestContents                ,+++-- ** clipboardRequestImage+    clipboardRequestImage                   ,+++-- ** clipboardRequestRichText+    clipboardRequestRichText                ,+++-- ** clipboardRequestTargets+    clipboardRequestTargets                 ,+++-- ** clipboardRequestText+    clipboardRequestText                    ,+++-- ** clipboardRequestUris+    clipboardRequestUris                    ,+++-- ** clipboardSetCanStore+    clipboardSetCanStore                    ,+++-- ** clipboardSetImage+    clipboardSetImage                       ,+++-- ** clipboardSetText+    clipboardSetText                        ,+++-- ** clipboardStore+    clipboardStore                          ,+++-- ** clipboardWaitForContents+    clipboardWaitForContents                ,+++-- ** clipboardWaitForImage+    clipboardWaitForImage                   ,+++-- ** clipboardWaitForRichText+    clipboardWaitForRichText                ,+++-- ** clipboardWaitForTargets+    clipboardWaitForTargets                 ,+++-- ** clipboardWaitForText+    clipboardWaitForText                    ,+++-- ** clipboardWaitForUris+    clipboardWaitForUris                    ,+++-- ** clipboardWaitIsImageAvailable+    clipboardWaitIsImageAvailable           ,+++-- ** clipboardWaitIsRichTextAvailable+    clipboardWaitIsRichTextAvailable        ,+++-- ** clipboardWaitIsTargetAvailable+    clipboardWaitIsTargetAvailable          ,+++-- ** clipboardWaitIsTextAvailable+    clipboardWaitIsTextAvailable            ,+++-- ** clipboardWaitIsUrisAvailable+    clipboardWaitIsUrisAvailable            ,+++++ -- * Signals+-- ** OwnerChange+    ClipboardOwnerChangeCallback            ,+    ClipboardOwnerChangeCallbackC           ,+    ClipboardOwnerChangeSignalInfo          ,+    afterClipboardOwnerChange               ,+    clipboardOwnerChangeCallbackWrapper     ,+    clipboardOwnerChangeClosure             ,+    mkClipboardOwnerChangeCallback          ,+    noClipboardOwnerChangeCallback          ,+    onClipboardOwnerChange                  ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf++newtype Clipboard = Clipboard (ForeignPtr Clipboard)+foreign import ccall "gtk_clipboard_get_type"+    c_gtk_clipboard_get_type :: IO GType++type instance ParentTypes Clipboard = ClipboardParentTypes+type ClipboardParentTypes = '[GObject.Object]++instance GObject Clipboard where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_clipboard_get_type+    ++class GObject o => ClipboardK o+instance (GObject o, IsDescendantOf Clipboard o) => ClipboardK o++toClipboard :: ClipboardK o => o -> IO Clipboard+toClipboard = unsafeCastTo Clipboard++noClipboard :: Maybe Clipboard+noClipboard = Nothing++-- signal Clipboard::owner-change+type ClipboardOwnerChangeCallback =+    Gdk.EventOwnerChange ->+    IO ()++noClipboardOwnerChangeCallback :: Maybe ClipboardOwnerChangeCallback+noClipboardOwnerChangeCallback = Nothing++type ClipboardOwnerChangeCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventOwnerChange ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkClipboardOwnerChangeCallback :: ClipboardOwnerChangeCallbackC -> IO (FunPtr ClipboardOwnerChangeCallbackC)++clipboardOwnerChangeClosure :: ClipboardOwnerChangeCallback -> IO Closure+clipboardOwnerChangeClosure cb = newCClosure =<< mkClipboardOwnerChangeCallback wrapped+    where wrapped = clipboardOwnerChangeCallbackWrapper cb++clipboardOwnerChangeCallbackWrapper ::+    ClipboardOwnerChangeCallback ->+    Ptr () ->+    Ptr Gdk.EventOwnerChange ->+    Ptr () ->+    IO ()+clipboardOwnerChangeCallbackWrapper _cb _ event _ = do+    event' <- (newPtr 56 Gdk.EventOwnerChange) event+    _cb  event'++onClipboardOwnerChange :: (GObject a, MonadIO m) => a -> ClipboardOwnerChangeCallback -> m SignalHandlerId+onClipboardOwnerChange obj cb = liftIO $ connectClipboardOwnerChange obj cb SignalConnectBefore+afterClipboardOwnerChange :: (GObject a, MonadIO m) => a -> ClipboardOwnerChangeCallback -> m SignalHandlerId+afterClipboardOwnerChange obj cb = connectClipboardOwnerChange obj cb SignalConnectAfter++connectClipboardOwnerChange :: (GObject a, MonadIO m) =>+                               a -> ClipboardOwnerChangeCallback -> SignalConnectMode -> m SignalHandlerId+connectClipboardOwnerChange obj cb after = liftIO $ do+    cb' <- mkClipboardOwnerChangeCallback (clipboardOwnerChangeCallbackWrapper cb)+    connectSignalFunPtr obj "owner-change" cb' after++type instance AttributeList Clipboard = ClipboardAttributeList+type ClipboardAttributeList = ('[ ] :: [(Symbol, *)])++data ClipboardOwnerChangeSignalInfo+instance SignalInfo ClipboardOwnerChangeSignalInfo where+    type HaskellCallbackType ClipboardOwnerChangeSignalInfo = ClipboardOwnerChangeCallback+    connectSignal _ = connectClipboardOwnerChange++type instance SignalList Clipboard = ClipboardSignalList+type ClipboardSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("owner-change", ClipboardOwnerChangeSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Clipboard::clear+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_clear" gtk_clipboard_clear :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO ()+++clipboardClear ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m ()+clipboardClear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_clipboard_clear _obj'+    touchManagedPtr _obj+    return ()++-- method Clipboard::get_display+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Display"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_get_display" gtk_clipboard_get_display :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO (Ptr Gdk.Display)+++clipboardGetDisplay ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m Gdk.Display+clipboardGetDisplay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_get_display _obj'+    checkUnexpectedReturnNULL "gtk_clipboard_get_display" result+    result' <- (newObject Gdk.Display) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::get_owner+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_get_owner" gtk_clipboard_get_owner :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO (Ptr GObject.Object)+++clipboardGetOwner ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m GObject.Object+clipboardGetOwner _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_get_owner _obj'+    checkUnexpectedReturnNULL "gtk_clipboard_get_owner" result+    result' <- (newObject GObject.Object) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::request_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardReceivedFunc", direction = DirectionIn, mayBeNull = False, 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 "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_contents" gtk_clipboard_request_contents :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr Gdk.Atom ->                         -- target : TInterface "Gdk" "Atom"+    FunPtr ClipboardReceivedFuncC ->        -- callback : TInterface "Gtk" "ClipboardReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestContents ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    Gdk.Atom ->                             -- target+    ClipboardReceivedFunc ->                -- callback+    m ()+clipboardRequestContents _obj target callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let target' = unsafeManagedPtrGetPtr target+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardReceivedFuncC))+    callback' <- mkClipboardReceivedFunc (clipboardReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_contents _obj' target' callback' user_data+    touchManagedPtr _obj+    touchManagedPtr target+    return ()++-- method Clipboard::request_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardImageReceivedFunc", direction = DirectionIn, mayBeNull = False, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardImageReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_image" gtk_clipboard_request_image :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    FunPtr ClipboardImageReceivedFuncC ->   -- callback : TInterface "Gtk" "ClipboardImageReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestImage ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    ClipboardImageReceivedFunc ->           -- callback+    m ()+clipboardRequestImage _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardImageReceivedFuncC))+    callback' <- mkClipboardImageReceivedFunc (clipboardImageReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_image _obj' callback' user_data+    touchManagedPtr _obj+    return ()++-- method Clipboard::request_rich_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardRichTextReceivedFunc", direction = DirectionIn, mayBeNull = False, 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 "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardRichTextReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_rich_text" gtk_clipboard_request_rich_text :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr TextBuffer ->                       -- buffer : TInterface "Gtk" "TextBuffer"+    FunPtr ClipboardRichTextReceivedFuncC -> -- callback : TInterface "Gtk" "ClipboardRichTextReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestRichText ::+    (MonadIO m, ClipboardK a, TextBufferK b) =>+    a ->                                    -- _obj+    b ->                                    -- buffer+    ClipboardRichTextReceivedFunc ->        -- callback+    m ()+clipboardRequestRichText _obj buffer callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let buffer' = unsafeManagedPtrCastPtr buffer+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardRichTextReceivedFuncC))+    callback' <- mkClipboardRichTextReceivedFunc (clipboardRichTextReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_rich_text _obj' buffer' callback' user_data+    touchManagedPtr _obj+    touchManagedPtr buffer+    return ()++-- method Clipboard::request_targets+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardTargetsReceivedFunc", direction = DirectionIn, mayBeNull = False, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardTargetsReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_targets" gtk_clipboard_request_targets :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    FunPtr ClipboardTargetsReceivedFuncC -> -- callback : TInterface "Gtk" "ClipboardTargetsReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestTargets ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    ClipboardTargetsReceivedFunc ->         -- callback+    m ()+clipboardRequestTargets _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardTargetsReceivedFuncC))+    callback' <- mkClipboardTargetsReceivedFunc (clipboardTargetsReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_targets _obj' callback' user_data+    touchManagedPtr _obj+    return ()++-- method Clipboard::request_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardTextReceivedFunc", direction = DirectionIn, mayBeNull = False, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardTextReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_text" gtk_clipboard_request_text :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    FunPtr ClipboardTextReceivedFuncC ->    -- callback : TInterface "Gtk" "ClipboardTextReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestText ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    ClipboardTextReceivedFunc ->            -- callback+    m ()+clipboardRequestText _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardTextReceivedFuncC))+    callback' <- mkClipboardTextReceivedFunc (clipboardTextReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_text _obj' callback' user_data+    touchManagedPtr _obj+    return ()++-- method Clipboard::request_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardURIReceivedFunc", direction = DirectionIn, mayBeNull = False, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "ClipboardURIReceivedFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_request_uris" gtk_clipboard_request_uris :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    FunPtr ClipboardURIReceivedFuncC ->     -- callback : TInterface "Gtk" "ClipboardURIReceivedFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++clipboardRequestUris ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    ClipboardURIReceivedFunc ->             -- callback+    m ()+clipboardRequestUris _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrcallback <- callocMem :: IO (Ptr (FunPtr ClipboardURIReceivedFuncC))+    callback' <- mkClipboardURIReceivedFunc (clipboardURIReceivedFuncWrapper (Just ptrcallback) callback)+    poke ptrcallback callback'+    let user_data = nullPtr+    gtk_clipboard_request_uris _obj' callback' user_data+    touchManagedPtr _obj+    return ()++-- method Clipboard::set_can_store+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_set_can_store" gtk_clipboard_set_can_store :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr TargetEntry ->                      -- targets : TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry")+    Int32 ->                                -- n_targets : TBasicType TInt32+    IO ()+++clipboardSetCanStore ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    Maybe ([TargetEntry]) ->                -- targets+    m ()+clipboardSetCanStore _obj targets = liftIO $ do+    let n_targets = case targets of+            Nothing -> 0+            Just jTargets -> fromIntegral $ length jTargets+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTargets <- case targets of+        Nothing -> return nullPtr+        Just jTargets -> do+            let jTargets' = map unsafeManagedPtrGetPtr jTargets+            jTargets'' <- packBlockArray 16 jTargets'+            return jTargets''+    gtk_clipboard_set_can_store _obj' maybeTargets n_targets+    touchManagedPtr _obj+    whenJust targets (mapM_ touchManagedPtr)+    freeMem maybeTargets+    return ()++-- method Clipboard::set_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_set_image" gtk_clipboard_set_image :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()+++clipboardSetImage ::+    (MonadIO m, ClipboardK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- _obj+    b ->                                    -- pixbuf+    m ()+clipboardSetImage _obj pixbuf = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    gtk_clipboard_set_image _obj' pixbuf'+    touchManagedPtr _obj+    touchManagedPtr pixbuf+    return ()++-- method Clipboard::set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = 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 : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_set_text" gtk_clipboard_set_text :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    CString ->                              -- text : TBasicType TUTF8+    Int32 ->                                -- len : TBasicType TInt32+    IO ()+++clipboardSetText ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    Int32 ->                                -- len+    m ()+clipboardSetText _obj text len = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_clipboard_set_text _obj' text' len+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method Clipboard::store+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_store" gtk_clipboard_store :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO ()+++clipboardStore ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m ()+clipboardStore _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_clipboard_store _obj'+    touchManagedPtr _obj+    return ()++-- method Clipboard::wait_for_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SelectionData"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_for_contents" gtk_clipboard_wait_for_contents :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr Gdk.Atom ->                         -- target : TInterface "Gdk" "Atom"+    IO (Ptr SelectionData)+++clipboardWaitForContents ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    Gdk.Atom ->                             -- target+    m SelectionData+clipboardWaitForContents _obj target = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let target' = unsafeManagedPtrGetPtr target+    result <- gtk_clipboard_wait_for_contents _obj' target'+    checkUnexpectedReturnNULL "gtk_clipboard_wait_for_contents" result+    result' <- (wrapBoxed SelectionData) result+    touchManagedPtr _obj+    touchManagedPtr target+    return result'++-- method Clipboard::wait_for_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_for_image" gtk_clipboard_wait_for_image :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO (Ptr GdkPixbuf.Pixbuf)+++clipboardWaitForImage ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+clipboardWaitForImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_for_image _obj'+    checkUnexpectedReturnNULL "gtk_clipboard_wait_for_image" result+    result' <- (wrapObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::wait_for_rich_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "format", argType = TInterface "Gdk" "Atom", direction = DirectionOut, 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 : [Arg {argName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 3 (TBasicType TUInt8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_for_rich_text" gtk_clipboard_wait_for_rich_text :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr TextBuffer ->                       -- buffer : TInterface "Gtk" "TextBuffer"+    Ptr (Ptr Gdk.Atom) ->                   -- format : TInterface "Gdk" "Atom"+    Ptr Word64 ->                           -- length : TBasicType TUInt64+    IO (Ptr Word8)+++clipboardWaitForRichText ::+    (MonadIO m, ClipboardK a, TextBufferK b) =>+    a ->                                    -- _obj+    b ->                                    -- buffer+    m (ByteString,Gdk.Atom)+clipboardWaitForRichText _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let buffer' = unsafeManagedPtrCastPtr buffer+    format <- allocMem :: IO (Ptr (Ptr Gdk.Atom))+    length_ <- allocMem :: IO (Ptr Word64)+    result <- gtk_clipboard_wait_for_rich_text _obj' buffer' format length_+    length_' <- peek length_+    checkUnexpectedReturnNULL "gtk_clipboard_wait_for_rich_text" result+    result' <- (unpackByteStringWithLength length_') result+    freeMem result+    format' <- peek format+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    format'' <- (\x -> Gdk.Atom <$> newForeignPtr_ x) format'+    touchManagedPtr _obj+    touchManagedPtr buffer+    freeMem format+    freeMem length_+    return (result', format'')++-- method Clipboard::wait_for_targets+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 2 (TInterface "Gdk" "Atom"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferContainer},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_for_targets" gtk_clipboard_wait_for_targets :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr (Ptr (Ptr Gdk.Atom)) ->             -- targets : TCArray False (-1) 2 (TInterface "Gdk" "Atom")+    Ptr Int32 ->                            -- n_targets : TBasicType TInt32+    IO CInt+++clipboardWaitForTargets ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m (Bool,[Gdk.Atom])+clipboardWaitForTargets _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    targets <- allocMem :: IO (Ptr (Ptr (Ptr Gdk.Atom)))+    n_targets <- allocMem :: IO (Ptr Int32)+    result <- gtk_clipboard_wait_for_targets _obj' targets n_targets+    n_targets' <- peek n_targets+    let result' = (/= 0) result+    targets' <- peek targets+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?+    targets'' <- (unpackPtrArrayWithLength n_targets') targets'+    targets''' <- mapM (\x -> Gdk.Atom <$> newForeignPtr_ x) targets''+    freeMem targets'+    touchManagedPtr _obj+    freeMem targets+    freeMem n_targets+    return (result', targets''')++-- method Clipboard::wait_for_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_for_text" gtk_clipboard_wait_for_text :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO CString+++clipboardWaitForText ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m T.Text+clipboardWaitForText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_for_text _obj'+    checkUnexpectedReturnNULL "gtk_clipboard_wait_for_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Clipboard::wait_for_uris+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", 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 "gtk_clipboard_wait_for_uris" gtk_clipboard_wait_for_uris :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO (Ptr CString)+++clipboardWaitForUris ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m [T.Text]+clipboardWaitForUris _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_for_uris _obj'+    checkUnexpectedReturnNULL "gtk_clipboard_wait_for_uris" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Clipboard::wait_is_image_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_is_image_available" gtk_clipboard_wait_is_image_available :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO CInt+++clipboardWaitIsImageAvailable ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m Bool+clipboardWaitIsImageAvailable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_is_image_available _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::wait_is_rich_text_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "TextBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_is_rich_text_available" gtk_clipboard_wait_is_rich_text_available :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr TextBuffer ->                       -- buffer : TInterface "Gtk" "TextBuffer"+    IO CInt+++clipboardWaitIsRichTextAvailable ::+    (MonadIO m, ClipboardK a, TextBufferK b) =>+    a ->                                    -- _obj+    b ->                                    -- buffer+    m Bool+clipboardWaitIsRichTextAvailable _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let buffer' = unsafeManagedPtrCastPtr buffer+    result <- gtk_clipboard_wait_is_rich_text_available _obj' buffer'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr buffer+    return result'++-- method Clipboard::wait_is_target_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_is_target_available" gtk_clipboard_wait_is_target_available :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    Ptr Gdk.Atom ->                         -- target : TInterface "Gdk" "Atom"+    IO CInt+++clipboardWaitIsTargetAvailable ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    Gdk.Atom ->                             -- target+    m Bool+clipboardWaitIsTargetAvailable _obj target = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let target' = unsafeManagedPtrGetPtr target+    result <- gtk_clipboard_wait_is_target_available _obj' target'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr target+    return result'++-- method Clipboard::wait_is_text_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_is_text_available" gtk_clipboard_wait_is_text_available :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO CInt+++clipboardWaitIsTextAvailable ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m Bool+clipboardWaitIsTextAvailable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_is_text_available _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::wait_is_uris_available+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Clipboard", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_wait_is_uris_available" gtk_clipboard_wait_is_uris_available :: +    Ptr Clipboard ->                        -- _obj : TInterface "Gtk" "Clipboard"+    IO CInt+++clipboardWaitIsUrisAvailable ::+    (MonadIO m, ClipboardK a) =>+    a ->                                    -- _obj+    m Bool+clipboardWaitIsUrisAvailable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_clipboard_wait_is_uris_available _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Clipboard::get+-- method type : MemberFunction+-- Args : [Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Clipboard"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_get" gtk_clipboard_get :: +    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    IO (Ptr Clipboard)+++clipboardGet ::+    (MonadIO m) =>+    Gdk.Atom ->                             -- selection+    m Clipboard+clipboardGet selection = liftIO $ do+    let selection' = unsafeManagedPtrGetPtr selection+    result <- gtk_clipboard_get selection'+    checkUnexpectedReturnNULL "gtk_clipboard_get" result+    result' <- (newObject Clipboard) result+    touchManagedPtr selection+    return result'++-- method Clipboard::get_default+-- method type : MemberFunction+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Clipboard"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_get_default" gtk_clipboard_get_default :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    IO (Ptr Clipboard)+++clipboardGetDefault ::+    (MonadIO m, Gdk.DisplayK a) =>+    a ->                                    -- display+    m Clipboard+clipboardGetDefault display = liftIO $ do+    let display' = unsafeManagedPtrCastPtr display+    result <- gtk_clipboard_get_default display'+    checkUnexpectedReturnNULL "gtk_clipboard_get_default" result+    result' <- (newObject Clipboard) result+    touchManagedPtr display+    return result'++-- method Clipboard::get_for_display+-- method type : MemberFunction+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Gdk" "Atom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Clipboard"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_clipboard_get_for_display" gtk_clipboard_get_for_display :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Ptr Gdk.Atom ->                         -- selection : TInterface "Gdk" "Atom"+    IO (Ptr Clipboard)+++clipboardGetForDisplay ::+    (MonadIO m, Gdk.DisplayK a) =>+    a ->                                    -- display+    Gdk.Atom ->                             -- selection+    m Clipboard+clipboardGetForDisplay display selection = liftIO $ do+    let display' = unsafeManagedPtrCastPtr display+    let selection' = unsafeManagedPtrGetPtr selection+    result <- gtk_clipboard_get_for_display display' selection'+    checkUnexpectedReturnNULL "gtk_clipboard_get_for_display" result+    result' <- (newObject Clipboard) result+    touchManagedPtr display+    touchManagedPtr selection+    return result'++
+ GI/Gtk/Objects/Clipboard.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.Clipboard where++import Prelude ()+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 Clipboard = Clipboard (ForeignPtr Clipboard)+instance GObject Clipboard where+class GObject o => ClipboardK o+instance (GObject o, IsDescendantOf Clipboard o) => ClipboardK o+data ClipboardOwnerChangeSignalInfo
+ GI/Gtk/Objects/ColorButton.hs view
@@ -0,0 +1,608 @@++{- |+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.Gtk.Objects.ColorButton+    ( ++-- * Exported types+    ColorButton(..)                         ,+    ColorButtonK                            ,+    toColorButton                           ,+    noColorButton                           ,+++ -- * Methods+-- ** colorButtonGetAlpha+    colorButtonGetAlpha                     ,+++-- ** colorButtonGetColor+    colorButtonGetColor                     ,+++-- ** colorButtonGetTitle+    colorButtonGetTitle                     ,+++-- ** colorButtonGetUseAlpha+    colorButtonGetUseAlpha                  ,+++-- ** colorButtonNew+    colorButtonNew                          ,+++-- ** colorButtonNewWithColor+    colorButtonNewWithColor                 ,+++-- ** colorButtonNewWithRgba+    colorButtonNewWithRgba                  ,+++-- ** colorButtonSetAlpha+    colorButtonSetAlpha                     ,+++-- ** colorButtonSetColor+    colorButtonSetColor                     ,+++-- ** colorButtonSetTitle+    colorButtonSetTitle                     ,+++-- ** colorButtonSetUseAlpha+    colorButtonSetUseAlpha                  ,+++++ -- * Properties+-- ** Alpha+    ColorButtonAlphaPropertyInfo            ,+    constructColorButtonAlpha               ,+    getColorButtonAlpha                     ,+    setColorButtonAlpha                     ,+++-- ** Color+    ColorButtonColorPropertyInfo            ,+    constructColorButtonColor               ,+    getColorButtonColor                     ,+    setColorButtonColor                     ,+++-- ** Rgba+    ColorButtonRgbaPropertyInfo             ,+    constructColorButtonRgba                ,+    getColorButtonRgba                      ,+    setColorButtonRgba                      ,+++-- ** Title+    ColorButtonTitlePropertyInfo            ,+    constructColorButtonTitle               ,+    getColorButtonTitle                     ,+    setColorButtonTitle                     ,+++-- ** UseAlpha+    ColorButtonUseAlphaPropertyInfo         ,+    constructColorButtonUseAlpha            ,+    getColorButtonUseAlpha                  ,+    setColorButtonUseAlpha                  ,+++++ -- * Signals+-- ** ColorSet+    ColorButtonColorSetCallback             ,+    ColorButtonColorSetCallbackC            ,+    ColorButtonColorSetSignalInfo           ,+    afterColorButtonColorSet                ,+    colorButtonColorSetCallbackWrapper      ,+    colorButtonColorSetClosure              ,+    mkColorButtonColorSetCallback           ,+    noColorButtonColorSetCallback           ,+    onColorButtonColorSet                   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype ColorButton = ColorButton (ForeignPtr ColorButton)+foreign import ccall "gtk_color_button_get_type"+    c_gtk_color_button_get_type :: IO GType++type instance ParentTypes ColorButton = ColorButtonParentTypes+type ColorButtonParentTypes = '[Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable, ColorChooser]++instance GObject ColorButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_color_button_get_type+    ++class GObject o => ColorButtonK o+instance (GObject o, IsDescendantOf ColorButton o) => ColorButtonK o++toColorButton :: ColorButtonK o => o -> IO ColorButton+toColorButton = unsafeCastTo ColorButton++noColorButton :: Maybe ColorButton+noColorButton = Nothing++-- signal ColorButton::color-set+type ColorButtonColorSetCallback =+    IO ()++noColorButtonColorSetCallback :: Maybe ColorButtonColorSetCallback+noColorButtonColorSetCallback = Nothing++type ColorButtonColorSetCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkColorButtonColorSetCallback :: ColorButtonColorSetCallbackC -> IO (FunPtr ColorButtonColorSetCallbackC)++colorButtonColorSetClosure :: ColorButtonColorSetCallback -> IO Closure+colorButtonColorSetClosure cb = newCClosure =<< mkColorButtonColorSetCallback wrapped+    where wrapped = colorButtonColorSetCallbackWrapper cb++colorButtonColorSetCallbackWrapper ::+    ColorButtonColorSetCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+colorButtonColorSetCallbackWrapper _cb _ _ = do+    _cb ++onColorButtonColorSet :: (GObject a, MonadIO m) => a -> ColorButtonColorSetCallback -> m SignalHandlerId+onColorButtonColorSet obj cb = liftIO $ connectColorButtonColorSet obj cb SignalConnectBefore+afterColorButtonColorSet :: (GObject a, MonadIO m) => a -> ColorButtonColorSetCallback -> m SignalHandlerId+afterColorButtonColorSet obj cb = connectColorButtonColorSet obj cb SignalConnectAfter++connectColorButtonColorSet :: (GObject a, MonadIO m) =>+                              a -> ColorButtonColorSetCallback -> SignalConnectMode -> m SignalHandlerId+connectColorButtonColorSet obj cb after = liftIO $ do+    cb' <- mkColorButtonColorSetCallback (colorButtonColorSetCallbackWrapper cb)+    connectSignalFunPtr obj "color-set" cb' after++-- VVV Prop "alpha"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getColorButtonAlpha :: (MonadIO m, ColorButtonK o) => o -> m Word32+getColorButtonAlpha obj = liftIO $ getObjectPropertyCUInt obj "alpha"++setColorButtonAlpha :: (MonadIO m, ColorButtonK o) => o -> Word32 -> m ()+setColorButtonAlpha obj val = liftIO $ setObjectPropertyCUInt obj "alpha" val++constructColorButtonAlpha :: Word32 -> IO ([Char], GValue)+constructColorButtonAlpha val = constructObjectPropertyCUInt "alpha" val++data ColorButtonAlphaPropertyInfo+instance AttrInfo ColorButtonAlphaPropertyInfo where+    type AttrAllowedOps ColorButtonAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorButtonAlphaPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ColorButtonAlphaPropertyInfo = ColorButtonK+    type AttrGetType ColorButtonAlphaPropertyInfo = Word32+    type AttrLabel ColorButtonAlphaPropertyInfo = "ColorButton::alpha"+    attrGet _ = getColorButtonAlpha+    attrSet _ = setColorButtonAlpha+    attrConstruct _ = constructColorButtonAlpha++-- VVV Prop "color"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getColorButtonColor :: (MonadIO m, ColorButtonK o) => o -> m Gdk.Color+getColorButtonColor obj = liftIO $ getObjectPropertyBoxed obj "color" Gdk.Color++setColorButtonColor :: (MonadIO m, ColorButtonK o) => o -> Gdk.Color -> m ()+setColorButtonColor obj val = liftIO $ setObjectPropertyBoxed obj "color" val++constructColorButtonColor :: Gdk.Color -> IO ([Char], GValue)+constructColorButtonColor val = constructObjectPropertyBoxed "color" val++data ColorButtonColorPropertyInfo+instance AttrInfo ColorButtonColorPropertyInfo where+    type AttrAllowedOps ColorButtonColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorButtonColorPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint ColorButtonColorPropertyInfo = ColorButtonK+    type AttrGetType ColorButtonColorPropertyInfo = Gdk.Color+    type AttrLabel ColorButtonColorPropertyInfo = "ColorButton::color"+    attrGet _ = getColorButtonColor+    attrSet _ = setColorButtonColor+    attrConstruct _ = constructColorButtonColor++-- VVV Prop "rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getColorButtonRgba :: (MonadIO m, ColorButtonK o) => o -> m Gdk.RGBA+getColorButtonRgba obj = liftIO $ getObjectPropertyBoxed obj "rgba" Gdk.RGBA++setColorButtonRgba :: (MonadIO m, ColorButtonK o) => o -> Gdk.RGBA -> m ()+setColorButtonRgba obj val = liftIO $ setObjectPropertyBoxed obj "rgba" val++constructColorButtonRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructColorButtonRgba val = constructObjectPropertyBoxed "rgba" val++data ColorButtonRgbaPropertyInfo+instance AttrInfo ColorButtonRgbaPropertyInfo where+    type AttrAllowedOps ColorButtonRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorButtonRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint ColorButtonRgbaPropertyInfo = ColorButtonK+    type AttrGetType ColorButtonRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel ColorButtonRgbaPropertyInfo = "ColorButton::rgba"+    attrGet _ = getColorButtonRgba+    attrSet _ = setColorButtonRgba+    attrConstruct _ = constructColorButtonRgba++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getColorButtonTitle :: (MonadIO m, ColorButtonK o) => o -> m T.Text+getColorButtonTitle obj = liftIO $ getObjectPropertyString obj "title"++setColorButtonTitle :: (MonadIO m, ColorButtonK o) => o -> T.Text -> m ()+setColorButtonTitle obj val = liftIO $ setObjectPropertyString obj "title" val++constructColorButtonTitle :: T.Text -> IO ([Char], GValue)+constructColorButtonTitle val = constructObjectPropertyString "title" val++data ColorButtonTitlePropertyInfo+instance AttrInfo ColorButtonTitlePropertyInfo where+    type AttrAllowedOps ColorButtonTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorButtonTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ColorButtonTitlePropertyInfo = ColorButtonK+    type AttrGetType ColorButtonTitlePropertyInfo = T.Text+    type AttrLabel ColorButtonTitlePropertyInfo = "ColorButton::title"+    attrGet _ = getColorButtonTitle+    attrSet _ = setColorButtonTitle+    attrConstruct _ = constructColorButtonTitle++-- VVV Prop "use-alpha"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorButtonUseAlpha :: (MonadIO m, ColorButtonK o) => o -> m Bool+getColorButtonUseAlpha obj = liftIO $ getObjectPropertyBool obj "use-alpha"++setColorButtonUseAlpha :: (MonadIO m, ColorButtonK o) => o -> Bool -> m ()+setColorButtonUseAlpha obj val = liftIO $ setObjectPropertyBool obj "use-alpha" val++constructColorButtonUseAlpha :: Bool -> IO ([Char], GValue)+constructColorButtonUseAlpha val = constructObjectPropertyBool "use-alpha" val++data ColorButtonUseAlphaPropertyInfo+instance AttrInfo ColorButtonUseAlphaPropertyInfo where+    type AttrAllowedOps ColorButtonUseAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorButtonUseAlphaPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorButtonUseAlphaPropertyInfo = ColorButtonK+    type AttrGetType ColorButtonUseAlphaPropertyInfo = Bool+    type AttrLabel ColorButtonUseAlphaPropertyInfo = "ColorButton::use-alpha"+    attrGet _ = getColorButtonUseAlpha+    attrSet _ = setColorButtonUseAlpha+    attrConstruct _ = constructColorButtonUseAlpha++type instance AttributeList ColorButton = ColorButtonAttributeList+type ColorButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("alpha", ColorButtonAlphaPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("color", ColorButtonColorPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("rgba", ColorButtonRgbaPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("title", ColorButtonTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-alpha", ColorButtonUseAlphaPropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++data ColorButtonColorSetSignalInfo+instance SignalInfo ColorButtonColorSetSignalInfo where+    type HaskellCallbackType ColorButtonColorSetSignalInfo = ColorButtonColorSetCallback+    connectSignal _ = connectColorButtonColorSet++type instance SignalList ColorButton = ColorButtonSignalList+type ColorButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("color-activated", ColorChooserColorActivatedSignalInfo), '("color-set", ColorButtonColorSetSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ColorButton::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ColorButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_new" gtk_color_button_new :: +    IO (Ptr ColorButton)+++colorButtonNew ::+    (MonadIO m) =>+    m ColorButton+colorButtonNew  = liftIO $ do+    result <- gtk_color_button_new+    checkUnexpectedReturnNULL "gtk_color_button_new" result+    result' <- (newObject ColorButton) result+    return result'++-- method ColorButton::new_with_color+-- method type : Constructor+-- Args : [Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ColorButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_new_with_color" gtk_color_button_new_with_color :: +    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO (Ptr ColorButton)++{-# DEPRECATED colorButtonNewWithColor ["(Since version 3.4)","Use gtk_color_button_new_with_rgba() instead."]#-}+colorButtonNewWithColor ::+    (MonadIO m) =>+    Gdk.Color ->                            -- color+    m ColorButton+colorButtonNewWithColor color = liftIO $ do+    let color' = unsafeManagedPtrGetPtr color+    result <- gtk_color_button_new_with_color color'+    checkUnexpectedReturnNULL "gtk_color_button_new_with_color" result+    result' <- (newObject ColorButton) result+    touchManagedPtr color+    return result'++-- method ColorButton::new_with_rgba+-- method type : Constructor+-- Args : [Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ColorButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_new_with_rgba" gtk_color_button_new_with_rgba :: +    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO (Ptr ColorButton)+++colorButtonNewWithRgba ::+    (MonadIO m) =>+    Gdk.RGBA ->                             -- rgba+    m ColorButton+colorButtonNewWithRgba rgba = liftIO $ do+    let rgba' = unsafeManagedPtrGetPtr rgba+    result <- gtk_color_button_new_with_rgba rgba'+    checkUnexpectedReturnNULL "gtk_color_button_new_with_rgba" result+    result' <- (newObject ColorButton) result+    touchManagedPtr rgba+    return result'++-- method ColorButton::get_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_get_alpha" gtk_color_button_get_alpha :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    IO Word16++{-# DEPRECATED colorButtonGetAlpha ["(Since version 3.4)","Use gtk_color_chooser_get_rgba() instead."]#-}+colorButtonGetAlpha ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    m Word16+colorButtonGetAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_button_get_alpha _obj'+    touchManagedPtr _obj+    return result++-- method ColorButton::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_get_color" gtk_color_button_get_color :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorButtonGetColor ["(Since version 3.4)","Use gtk_color_chooser_get_rgba() instead."]#-}+colorButtonGetColor ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    m (Gdk.Color)+colorButtonGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 12 :: IO (Ptr Gdk.Color)+    gtk_color_button_get_color _obj' color+    color' <- (wrapBoxed Gdk.Color) color+    touchManagedPtr _obj+    return color'++-- method ColorButton::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_get_title" gtk_color_button_get_title :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    IO CString+++colorButtonGetTitle ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    m T.Text+colorButtonGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_button_get_title _obj'+    checkUnexpectedReturnNULL "gtk_color_button_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ColorButton::get_use_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_get_use_alpha" gtk_color_button_get_use_alpha :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    IO CInt++{-# DEPRECATED colorButtonGetUseAlpha ["(Since version 3.4)","Use gtk_color_chooser_get_use_alpha() instead."]#-}+colorButtonGetUseAlpha ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    m Bool+colorButtonGetUseAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_button_get_use_alpha _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ColorButton::set_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_set_alpha" gtk_color_button_set_alpha :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    Word16 ->                               -- alpha : TBasicType TUInt16+    IO ()++{-# DEPRECATED colorButtonSetAlpha ["(Since version 3.4)","Use gtk_color_chooser_set_rgba() instead."]#-}+colorButtonSetAlpha ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    Word16 ->                               -- alpha+    m ()+colorButtonSetAlpha _obj alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_color_button_set_alpha _obj' alpha+    touchManagedPtr _obj+    return ()++-- method ColorButton::set_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_button_set_color" gtk_color_button_set_color :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorButtonSetColor ["Use gtk_color_chooser_set_rgba() instead."]#-}+colorButtonSetColor ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    Gdk.Color ->                            -- color+    m ()+colorButtonSetColor _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let color' = unsafeManagedPtrGetPtr color+    gtk_color_button_set_color _obj' color'+    touchManagedPtr _obj+    touchManagedPtr color+    return ()++-- method ColorButton::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", 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 "Gtk" "ColorButton", 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 "gtk_color_button_set_title" gtk_color_button_set_title :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++colorButtonSetTitle ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+colorButtonSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    gtk_color_button_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method ColorButton::set_use_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_alpha", 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 "gtk_color_button_set_use_alpha" gtk_color_button_set_use_alpha :: +    Ptr ColorButton ->                      -- _obj : TInterface "Gtk" "ColorButton"+    CInt ->                                 -- use_alpha : TBasicType TBoolean+    IO ()++{-# DEPRECATED colorButtonSetUseAlpha ["(Since version 3.4)","Use gtk_color_chooser_set_use_alpha() instead."]#-}+colorButtonSetUseAlpha ::+    (MonadIO m, ColorButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_alpha+    m ()+colorButtonSetUseAlpha _obj use_alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_alpha' = (fromIntegral . fromEnum) use_alpha+    gtk_color_button_set_use_alpha _obj' use_alpha'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ColorButton.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.ColorButton where++import Prelude ()+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 ColorButton = ColorButton (ForeignPtr ColorButton)+instance GObject ColorButton where+class GObject o => ColorButtonK o+instance (GObject o, IsDescendantOf ColorButton o) => ColorButtonK o+data ColorButtonAlphaPropertyInfo+data ColorButtonColorPropertyInfo+data ColorButtonRgbaPropertyInfo+data ColorButtonTitlePropertyInfo+data ColorButtonUseAlphaPropertyInfo+data ColorButtonColorSetSignalInfo
+ GI/Gtk/Objects/ColorChooserDialog.hs view
@@ -0,0 +1,138 @@++{- |+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.Gtk.Objects.ColorChooserDialog+    ( ++-- * Exported types+    ColorChooserDialog(..)                  ,+    ColorChooserDialogK                     ,+    toColorChooserDialog                    ,+    noColorChooserDialog                    ,+++ -- * Methods+-- ** colorChooserDialogNew+    colorChooserDialogNew                   ,+++++ -- * Properties+-- ** ShowEditor+    ColorChooserDialogShowEditorPropertyInfo,+    constructColorChooserDialogShowEditor   ,+    getColorChooserDialogShowEditor         ,+    setColorChooserDialogShowEditor         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ColorChooserDialog = ColorChooserDialog (ForeignPtr ColorChooserDialog)+foreign import ccall "gtk_color_chooser_dialog_get_type"+    c_gtk_color_chooser_dialog_get_type :: IO GType++type instance ParentTypes ColorChooserDialog = ColorChooserDialogParentTypes+type ColorChooserDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, ColorChooser]++instance GObject ColorChooserDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_color_chooser_dialog_get_type+    ++class GObject o => ColorChooserDialogK o+instance (GObject o, IsDescendantOf ColorChooserDialog o) => ColorChooserDialogK o++toColorChooserDialog :: ColorChooserDialogK o => o -> IO ColorChooserDialog+toColorChooserDialog = unsafeCastTo ColorChooserDialog++noColorChooserDialog :: Maybe ColorChooserDialog+noColorChooserDialog = Nothing++-- VVV Prop "show-editor"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorChooserDialogShowEditor :: (MonadIO m, ColorChooserDialogK o) => o -> m Bool+getColorChooserDialogShowEditor obj = liftIO $ getObjectPropertyBool obj "show-editor"++setColorChooserDialogShowEditor :: (MonadIO m, ColorChooserDialogK o) => o -> Bool -> m ()+setColorChooserDialogShowEditor obj val = liftIO $ setObjectPropertyBool obj "show-editor" val++constructColorChooserDialogShowEditor :: Bool -> IO ([Char], GValue)+constructColorChooserDialogShowEditor val = constructObjectPropertyBool "show-editor" val++data ColorChooserDialogShowEditorPropertyInfo+instance AttrInfo ColorChooserDialogShowEditorPropertyInfo where+    type AttrAllowedOps ColorChooserDialogShowEditorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorChooserDialogShowEditorPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorChooserDialogShowEditorPropertyInfo = ColorChooserDialogK+    type AttrGetType ColorChooserDialogShowEditorPropertyInfo = Bool+    type AttrLabel ColorChooserDialogShowEditorPropertyInfo = "ColorChooserDialog::show-editor"+    attrGet _ = getColorChooserDialogShowEditor+    attrSet _ = setColorChooserDialogShowEditor+    attrConstruct _ = constructColorChooserDialogShowEditor++type instance AttributeList ColorChooserDialog = ColorChooserDialogAttributeList+type ColorChooserDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("rgba", ColorChooserRgbaPropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-editor", ColorChooserDialogShowEditorPropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-alpha", ColorChooserUseAlphaPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ColorChooserDialog = ColorChooserDialogSignalList+type ColorChooserDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("color-activated", ColorChooserColorActivatedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ColorChooserDialog::new+-- method type : Constructor+-- Args : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ColorChooserDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_dialog_new" gtk_color_chooser_dialog_new :: +    CString ->                              -- title : TBasicType TUTF8+    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    IO (Ptr ColorChooserDialog)+++colorChooserDialogNew ::+    (MonadIO m, WindowK a) =>+    Maybe (T.Text) ->                       -- title+    Maybe (a) ->                            -- parent+    m ColorChooserDialog+colorChooserDialogNew title parent = liftIO $ do+    maybeTitle <- case title of+        Nothing -> return nullPtr+        Just jTitle -> do+            jTitle' <- textToCString jTitle+            return jTitle'+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- gtk_color_chooser_dialog_new maybeTitle maybeParent+    checkUnexpectedReturnNULL "gtk_color_chooser_dialog_new" result+    result' <- (newObject ColorChooserDialog) result+    whenJust parent touchManagedPtr+    freeMem maybeTitle+    return result'++
+ GI/Gtk/Objects/ColorChooserDialog.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.ColorChooserDialog where++import Prelude ()+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 ColorChooserDialog = ColorChooserDialog (ForeignPtr ColorChooserDialog)+instance GObject ColorChooserDialog where+class GObject o => ColorChooserDialogK o+instance (GObject o, IsDescendantOf ColorChooserDialog o) => ColorChooserDialogK o+data ColorChooserDialogShowEditorPropertyInfo
+ GI/Gtk/Objects/ColorChooserWidget.hs view
@@ -0,0 +1,122 @@++{- |+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.Gtk.Objects.ColorChooserWidget+    ( ++-- * Exported types+    ColorChooserWidget(..)                  ,+    ColorChooserWidgetK                     ,+    toColorChooserWidget                    ,+    noColorChooserWidget                    ,+++ -- * Methods+-- ** colorChooserWidgetNew+    colorChooserWidgetNew                   ,+++++ -- * Properties+-- ** ShowEditor+    ColorChooserWidgetShowEditorPropertyInfo,+    constructColorChooserWidgetShowEditor   ,+    getColorChooserWidgetShowEditor         ,+    setColorChooserWidgetShowEditor         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ColorChooserWidget = ColorChooserWidget (ForeignPtr ColorChooserWidget)+foreign import ccall "gtk_color_chooser_widget_get_type"+    c_gtk_color_chooser_widget_get_type :: IO GType++type instance ParentTypes ColorChooserWidget = ColorChooserWidgetParentTypes+type ColorChooserWidgetParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, ColorChooser, Orientable]++instance GObject ColorChooserWidget where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_color_chooser_widget_get_type+    ++class GObject o => ColorChooserWidgetK o+instance (GObject o, IsDescendantOf ColorChooserWidget o) => ColorChooserWidgetK o++toColorChooserWidget :: ColorChooserWidgetK o => o -> IO ColorChooserWidget+toColorChooserWidget = unsafeCastTo ColorChooserWidget++noColorChooserWidget :: Maybe ColorChooserWidget+noColorChooserWidget = Nothing++-- VVV Prop "show-editor"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorChooserWidgetShowEditor :: (MonadIO m, ColorChooserWidgetK o) => o -> m Bool+getColorChooserWidgetShowEditor obj = liftIO $ getObjectPropertyBool obj "show-editor"++setColorChooserWidgetShowEditor :: (MonadIO m, ColorChooserWidgetK o) => o -> Bool -> m ()+setColorChooserWidgetShowEditor obj val = liftIO $ setObjectPropertyBool obj "show-editor" val++constructColorChooserWidgetShowEditor :: Bool -> IO ([Char], GValue)+constructColorChooserWidgetShowEditor val = constructObjectPropertyBool "show-editor" val++data ColorChooserWidgetShowEditorPropertyInfo+instance AttrInfo ColorChooserWidgetShowEditorPropertyInfo where+    type AttrAllowedOps ColorChooserWidgetShowEditorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorChooserWidgetShowEditorPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorChooserWidgetShowEditorPropertyInfo = ColorChooserWidgetK+    type AttrGetType ColorChooserWidgetShowEditorPropertyInfo = Bool+    type AttrLabel ColorChooserWidgetShowEditorPropertyInfo = "ColorChooserWidget::show-editor"+    attrGet _ = getColorChooserWidgetShowEditor+    attrSet _ = setColorChooserWidgetShowEditor+    attrConstruct _ = constructColorChooserWidgetShowEditor++type instance AttributeList ColorChooserWidget = ColorChooserWidgetAttributeList+type ColorChooserWidgetAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("rgba", ColorChooserRgbaPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-editor", ColorChooserWidgetShowEditorPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-alpha", ColorChooserUseAlphaPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ColorChooserWidget = ColorChooserWidgetSignalList+type ColorChooserWidgetSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("color-activated", ColorChooserColorActivatedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ColorChooserWidget::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ColorChooserWidget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_chooser_widget_new" gtk_color_chooser_widget_new :: +    IO (Ptr ColorChooserWidget)+++colorChooserWidgetNew ::+    (MonadIO m) =>+    m ColorChooserWidget+colorChooserWidgetNew  = liftIO $ do+    result <- gtk_color_chooser_widget_new+    checkUnexpectedReturnNULL "gtk_color_chooser_widget_new" result+    result' <- (newObject ColorChooserWidget) result+    return result'++
+ GI/Gtk/Objects/ColorChooserWidget.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.ColorChooserWidget where++import Prelude ()+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 ColorChooserWidget = ColorChooserWidget (ForeignPtr ColorChooserWidget)+instance GObject ColorChooserWidget where+class GObject o => ColorChooserWidgetK o+instance (GObject o, IsDescendantOf ColorChooserWidget o) => ColorChooserWidgetK o+data ColorChooserWidgetShowEditorPropertyInfo
+ GI/Gtk/Objects/ColorSelection.hs view
@@ -0,0 +1,897 @@++{- |+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.Gtk.Objects.ColorSelection+    ( ++-- * Exported types+    ColorSelection(..)                      ,+    ColorSelectionK                         ,+    toColorSelection                        ,+    noColorSelection                        ,+++ -- * Methods+-- ** colorSelectionGetCurrentAlpha+    colorSelectionGetCurrentAlpha           ,+++-- ** colorSelectionGetCurrentColor+    colorSelectionGetCurrentColor           ,+++-- ** colorSelectionGetCurrentRgba+    colorSelectionGetCurrentRgba            ,+++-- ** colorSelectionGetHasOpacityControl+    colorSelectionGetHasOpacityControl      ,+++-- ** colorSelectionGetHasPalette+    colorSelectionGetHasPalette             ,+++-- ** colorSelectionGetPreviousAlpha+    colorSelectionGetPreviousAlpha          ,+++-- ** colorSelectionGetPreviousColor+    colorSelectionGetPreviousColor          ,+++-- ** colorSelectionGetPreviousRgba+    colorSelectionGetPreviousRgba           ,+++-- ** colorSelectionIsAdjusting+    colorSelectionIsAdjusting               ,+++-- ** colorSelectionNew+    colorSelectionNew                       ,+++-- ** colorSelectionPaletteFromString+    colorSelectionPaletteFromString         ,+++-- ** colorSelectionPaletteToString+    colorSelectionPaletteToString           ,+++-- ** colorSelectionSetCurrentAlpha+    colorSelectionSetCurrentAlpha           ,+++-- ** colorSelectionSetCurrentColor+    colorSelectionSetCurrentColor           ,+++-- ** colorSelectionSetCurrentRgba+    colorSelectionSetCurrentRgba            ,+++-- ** colorSelectionSetHasOpacityControl+    colorSelectionSetHasOpacityControl      ,+++-- ** colorSelectionSetHasPalette+    colorSelectionSetHasPalette             ,+++-- ** colorSelectionSetPreviousAlpha+    colorSelectionSetPreviousAlpha          ,+++-- ** colorSelectionSetPreviousColor+    colorSelectionSetPreviousColor          ,+++-- ** colorSelectionSetPreviousRgba+    colorSelectionSetPreviousRgba           ,+++++ -- * Properties+-- ** CurrentAlpha+    ColorSelectionCurrentAlphaPropertyInfo  ,+    constructColorSelectionCurrentAlpha     ,+    getColorSelectionCurrentAlpha           ,+    setColorSelectionCurrentAlpha           ,+++-- ** CurrentColor+    ColorSelectionCurrentColorPropertyInfo  ,+    constructColorSelectionCurrentColor     ,+    getColorSelectionCurrentColor           ,+    setColorSelectionCurrentColor           ,+++-- ** CurrentRgba+    ColorSelectionCurrentRgbaPropertyInfo   ,+    constructColorSelectionCurrentRgba      ,+    getColorSelectionCurrentRgba            ,+    setColorSelectionCurrentRgba            ,+++-- ** HasOpacityControl+    ColorSelectionHasOpacityControlPropertyInfo,+    constructColorSelectionHasOpacityControl,+    getColorSelectionHasOpacityControl      ,+    setColorSelectionHasOpacityControl      ,+++-- ** HasPalette+    ColorSelectionHasPalettePropertyInfo    ,+    constructColorSelectionHasPalette       ,+    getColorSelectionHasPalette             ,+    setColorSelectionHasPalette             ,+++++ -- * Signals+-- ** ColorChanged+    ColorSelectionColorChangedCallback      ,+    ColorSelectionColorChangedCallbackC     ,+    ColorSelectionColorChangedSignalInfo    ,+    afterColorSelectionColorChanged         ,+    colorSelectionColorChangedCallbackWrapper,+    colorSelectionColorChangedClosure       ,+    mkColorSelectionColorChangedCallback    ,+    noColorSelectionColorChangedCallback    ,+    onColorSelectionColorChanged            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype ColorSelection = ColorSelection (ForeignPtr ColorSelection)+foreign import ccall "gtk_color_selection_get_type"+    c_gtk_color_selection_get_type :: IO GType++type instance ParentTypes ColorSelection = ColorSelectionParentTypes+type ColorSelectionParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject ColorSelection where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_color_selection_get_type+    ++class GObject o => ColorSelectionK o+instance (GObject o, IsDescendantOf ColorSelection o) => ColorSelectionK o++toColorSelection :: ColorSelectionK o => o -> IO ColorSelection+toColorSelection = unsafeCastTo ColorSelection++noColorSelection :: Maybe ColorSelection+noColorSelection = Nothing++-- signal ColorSelection::color-changed+type ColorSelectionColorChangedCallback =+    IO ()++noColorSelectionColorChangedCallback :: Maybe ColorSelectionColorChangedCallback+noColorSelectionColorChangedCallback = Nothing++type ColorSelectionColorChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkColorSelectionColorChangedCallback :: ColorSelectionColorChangedCallbackC -> IO (FunPtr ColorSelectionColorChangedCallbackC)++colorSelectionColorChangedClosure :: ColorSelectionColorChangedCallback -> IO Closure+colorSelectionColorChangedClosure cb = newCClosure =<< mkColorSelectionColorChangedCallback wrapped+    where wrapped = colorSelectionColorChangedCallbackWrapper cb++colorSelectionColorChangedCallbackWrapper ::+    ColorSelectionColorChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+colorSelectionColorChangedCallbackWrapper _cb _ _ = do+    _cb ++onColorSelectionColorChanged :: (GObject a, MonadIO m) => a -> ColorSelectionColorChangedCallback -> m SignalHandlerId+onColorSelectionColorChanged obj cb = liftIO $ connectColorSelectionColorChanged obj cb SignalConnectBefore+afterColorSelectionColorChanged :: (GObject a, MonadIO m) => a -> ColorSelectionColorChangedCallback -> m SignalHandlerId+afterColorSelectionColorChanged obj cb = connectColorSelectionColorChanged obj cb SignalConnectAfter++connectColorSelectionColorChanged :: (GObject a, MonadIO m) =>+                                     a -> ColorSelectionColorChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectColorSelectionColorChanged obj cb after = liftIO $ do+    cb' <- mkColorSelectionColorChangedCallback (colorSelectionColorChangedCallbackWrapper cb)+    connectSignalFunPtr obj "color-changed" cb' after++-- VVV Prop "current-alpha"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getColorSelectionCurrentAlpha :: (MonadIO m, ColorSelectionK o) => o -> m Word32+getColorSelectionCurrentAlpha obj = liftIO $ getObjectPropertyCUInt obj "current-alpha"++setColorSelectionCurrentAlpha :: (MonadIO m, ColorSelectionK o) => o -> Word32 -> m ()+setColorSelectionCurrentAlpha obj val = liftIO $ setObjectPropertyCUInt obj "current-alpha" val++constructColorSelectionCurrentAlpha :: Word32 -> IO ([Char], GValue)+constructColorSelectionCurrentAlpha val = constructObjectPropertyCUInt "current-alpha" val++data ColorSelectionCurrentAlphaPropertyInfo+instance AttrInfo ColorSelectionCurrentAlphaPropertyInfo where+    type AttrAllowedOps ColorSelectionCurrentAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionCurrentAlphaPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ColorSelectionCurrentAlphaPropertyInfo = ColorSelectionK+    type AttrGetType ColorSelectionCurrentAlphaPropertyInfo = Word32+    type AttrLabel ColorSelectionCurrentAlphaPropertyInfo = "ColorSelection::current-alpha"+    attrGet _ = getColorSelectionCurrentAlpha+    attrSet _ = setColorSelectionCurrentAlpha+    attrConstruct _ = constructColorSelectionCurrentAlpha++-- VVV Prop "current-color"+   -- Type: TInterface "Gdk" "Color"+   -- Flags: [PropertyReadable,PropertyWritable]++getColorSelectionCurrentColor :: (MonadIO m, ColorSelectionK o) => o -> m Gdk.Color+getColorSelectionCurrentColor obj = liftIO $ getObjectPropertyBoxed obj "current-color" Gdk.Color++setColorSelectionCurrentColor :: (MonadIO m, ColorSelectionK o) => o -> Gdk.Color -> m ()+setColorSelectionCurrentColor obj val = liftIO $ setObjectPropertyBoxed obj "current-color" val++constructColorSelectionCurrentColor :: Gdk.Color -> IO ([Char], GValue)+constructColorSelectionCurrentColor val = constructObjectPropertyBoxed "current-color" val++data ColorSelectionCurrentColorPropertyInfo+instance AttrInfo ColorSelectionCurrentColorPropertyInfo where+    type AttrAllowedOps ColorSelectionCurrentColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionCurrentColorPropertyInfo = (~) Gdk.Color+    type AttrBaseTypeConstraint ColorSelectionCurrentColorPropertyInfo = ColorSelectionK+    type AttrGetType ColorSelectionCurrentColorPropertyInfo = Gdk.Color+    type AttrLabel ColorSelectionCurrentColorPropertyInfo = "ColorSelection::current-color"+    attrGet _ = getColorSelectionCurrentColor+    attrSet _ = setColorSelectionCurrentColor+    attrConstruct _ = constructColorSelectionCurrentColor++-- VVV Prop "current-rgba"+   -- Type: TInterface "Gdk" "RGBA"+   -- Flags: [PropertyReadable,PropertyWritable]++getColorSelectionCurrentRgba :: (MonadIO m, ColorSelectionK o) => o -> m Gdk.RGBA+getColorSelectionCurrentRgba obj = liftIO $ getObjectPropertyBoxed obj "current-rgba" Gdk.RGBA++setColorSelectionCurrentRgba :: (MonadIO m, ColorSelectionK o) => o -> Gdk.RGBA -> m ()+setColorSelectionCurrentRgba obj val = liftIO $ setObjectPropertyBoxed obj "current-rgba" val++constructColorSelectionCurrentRgba :: Gdk.RGBA -> IO ([Char], GValue)+constructColorSelectionCurrentRgba val = constructObjectPropertyBoxed "current-rgba" val++data ColorSelectionCurrentRgbaPropertyInfo+instance AttrInfo ColorSelectionCurrentRgbaPropertyInfo where+    type AttrAllowedOps ColorSelectionCurrentRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionCurrentRgbaPropertyInfo = (~) Gdk.RGBA+    type AttrBaseTypeConstraint ColorSelectionCurrentRgbaPropertyInfo = ColorSelectionK+    type AttrGetType ColorSelectionCurrentRgbaPropertyInfo = Gdk.RGBA+    type AttrLabel ColorSelectionCurrentRgbaPropertyInfo = "ColorSelection::current-rgba"+    attrGet _ = getColorSelectionCurrentRgba+    attrSet _ = setColorSelectionCurrentRgba+    attrConstruct _ = constructColorSelectionCurrentRgba++-- VVV Prop "has-opacity-control"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorSelectionHasOpacityControl :: (MonadIO m, ColorSelectionK o) => o -> m Bool+getColorSelectionHasOpacityControl obj = liftIO $ getObjectPropertyBool obj "has-opacity-control"++setColorSelectionHasOpacityControl :: (MonadIO m, ColorSelectionK o) => o -> Bool -> m ()+setColorSelectionHasOpacityControl obj val = liftIO $ setObjectPropertyBool obj "has-opacity-control" val++constructColorSelectionHasOpacityControl :: Bool -> IO ([Char], GValue)+constructColorSelectionHasOpacityControl val = constructObjectPropertyBool "has-opacity-control" val++data ColorSelectionHasOpacityControlPropertyInfo+instance AttrInfo ColorSelectionHasOpacityControlPropertyInfo where+    type AttrAllowedOps ColorSelectionHasOpacityControlPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionHasOpacityControlPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorSelectionHasOpacityControlPropertyInfo = ColorSelectionK+    type AttrGetType ColorSelectionHasOpacityControlPropertyInfo = Bool+    type AttrLabel ColorSelectionHasOpacityControlPropertyInfo = "ColorSelection::has-opacity-control"+    attrGet _ = getColorSelectionHasOpacityControl+    attrSet _ = setColorSelectionHasOpacityControl+    attrConstruct _ = constructColorSelectionHasOpacityControl++-- VVV Prop "has-palette"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getColorSelectionHasPalette :: (MonadIO m, ColorSelectionK o) => o -> m Bool+getColorSelectionHasPalette obj = liftIO $ getObjectPropertyBool obj "has-palette"++setColorSelectionHasPalette :: (MonadIO m, ColorSelectionK o) => o -> Bool -> m ()+setColorSelectionHasPalette obj val = liftIO $ setObjectPropertyBool obj "has-palette" val++constructColorSelectionHasPalette :: Bool -> IO ([Char], GValue)+constructColorSelectionHasPalette val = constructObjectPropertyBool "has-palette" val++data ColorSelectionHasPalettePropertyInfo+instance AttrInfo ColorSelectionHasPalettePropertyInfo where+    type AttrAllowedOps ColorSelectionHasPalettePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionHasPalettePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ColorSelectionHasPalettePropertyInfo = ColorSelectionK+    type AttrGetType ColorSelectionHasPalettePropertyInfo = Bool+    type AttrLabel ColorSelectionHasPalettePropertyInfo = "ColorSelection::has-palette"+    attrGet _ = getColorSelectionHasPalette+    attrSet _ = setColorSelectionHasPalette+    attrConstruct _ = constructColorSelectionHasPalette++type instance AttributeList ColorSelection = ColorSelectionAttributeList+type ColorSelectionAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("current-alpha", ColorSelectionCurrentAlphaPropertyInfo), '("current-color", ColorSelectionCurrentColorPropertyInfo), '("current-rgba", ColorSelectionCurrentRgbaPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-opacity-control", ColorSelectionHasOpacityControlPropertyInfo), '("has-palette", ColorSelectionHasPalettePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data ColorSelectionColorChangedSignalInfo+instance SignalInfo ColorSelectionColorChangedSignalInfo where+    type HaskellCallbackType ColorSelectionColorChangedSignalInfo = ColorSelectionColorChangedCallback+    connectSignal _ = connectColorSelectionColorChanged++type instance SignalList ColorSelection = ColorSelectionSignalList+type ColorSelectionSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("color-changed", ColorSelectionColorChangedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ColorSelection::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ColorSelection"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_new" gtk_color_selection_new :: +    IO (Ptr ColorSelection)+++colorSelectionNew ::+    (MonadIO m) =>+    m ColorSelection+colorSelectionNew  = liftIO $ do+    result <- gtk_color_selection_new+    checkUnexpectedReturnNULL "gtk_color_selection_new" result+    result' <- (newObject ColorSelection) result+    return result'++-- method ColorSelection::get_current_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_current_alpha" gtk_color_selection_get_current_alpha :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    IO Word16+++colorSelectionGetCurrentAlpha ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m Word16+colorSelectionGetCurrentAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_get_current_alpha _obj'+    touchManagedPtr _obj+    return result++-- method ColorSelection::get_current_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_current_color" gtk_color_selection_get_current_color :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorSelectionGetCurrentColor ["(Since version 3.4)","Use gtk_color_selection_get_current_rgba() instead."]#-}+colorSelectionGetCurrentColor ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m (Gdk.Color)+colorSelectionGetCurrentColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 12 :: IO (Ptr Gdk.Color)+    gtk_color_selection_get_current_color _obj' color+    color' <- (wrapBoxed Gdk.Color) color+    touchManagedPtr _obj+    return color'++-- method ColorSelection::get_current_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_current_rgba" gtk_color_selection_get_current_rgba :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO ()+++colorSelectionGetCurrentRgba ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m (Gdk.RGBA)+colorSelectionGetCurrentRgba _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rgba <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA)+    gtk_color_selection_get_current_rgba _obj' rgba+    rgba' <- (wrapBoxed Gdk.RGBA) rgba+    touchManagedPtr _obj+    return rgba'++-- method ColorSelection::get_has_opacity_control+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_has_opacity_control" gtk_color_selection_get_has_opacity_control :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    IO CInt+++colorSelectionGetHasOpacityControl ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m Bool+colorSelectionGetHasOpacityControl _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_get_has_opacity_control _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ColorSelection::get_has_palette+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_has_palette" gtk_color_selection_get_has_palette :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    IO CInt+++colorSelectionGetHasPalette ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m Bool+colorSelectionGetHasPalette _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_get_has_palette _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ColorSelection::get_previous_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_previous_alpha" gtk_color_selection_get_previous_alpha :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    IO Word16+++colorSelectionGetPreviousAlpha ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m Word16+colorSelectionGetPreviousAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_get_previous_alpha _obj'+    touchManagedPtr _obj+    return result++-- method ColorSelection::get_previous_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_previous_color" gtk_color_selection_get_previous_color :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorSelectionGetPreviousColor ["(Since version 3.4)","Use gtk_color_selection_get_previous_rgba() instead."]#-}+colorSelectionGetPreviousColor ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m (Gdk.Color)+colorSelectionGetPreviousColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 12 :: IO (Ptr Gdk.Color)+    gtk_color_selection_get_previous_color _obj' color+    color' <- (wrapBoxed Gdk.Color) color+    touchManagedPtr _obj+    return color'++-- method ColorSelection::get_previous_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_get_previous_rgba" gtk_color_selection_get_previous_rgba :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO ()+++colorSelectionGetPreviousRgba ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m (Gdk.RGBA)+colorSelectionGetPreviousRgba _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rgba <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA)+    gtk_color_selection_get_previous_rgba _obj' rgba+    rgba' <- (wrapBoxed Gdk.RGBA) rgba+    touchManagedPtr _obj+    return rgba'++-- method ColorSelection::is_adjusting+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_is_adjusting" gtk_color_selection_is_adjusting :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    IO CInt+++colorSelectionIsAdjusting ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    m Bool+colorSelectionIsAdjusting _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_is_adjusting _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ColorSelection::set_current_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_current_alpha" gtk_color_selection_set_current_alpha :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Word16 ->                               -- alpha : TBasicType TUInt16+    IO ()+++colorSelectionSetCurrentAlpha ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Word16 ->                               -- alpha+    m ()+colorSelectionSetCurrentAlpha _obj alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_color_selection_set_current_alpha _obj' alpha+    touchManagedPtr _obj+    return ()++-- method ColorSelection::set_current_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_current_color" gtk_color_selection_set_current_color :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorSelectionSetCurrentColor ["(Since version 3.4)","Use gtk_color_selection_set_current_rgba() instead."]#-}+colorSelectionSetCurrentColor ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Gdk.Color ->                            -- color+    m ()+colorSelectionSetCurrentColor _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let color' = unsafeManagedPtrGetPtr color+    gtk_color_selection_set_current_color _obj' color'+    touchManagedPtr _obj+    touchManagedPtr color+    return ()++-- method ColorSelection::set_current_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_current_rgba" gtk_color_selection_set_current_rgba :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO ()+++colorSelectionSetCurrentRgba ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- rgba+    m ()+colorSelectionSetCurrentRgba _obj rgba = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let rgba' = unsafeManagedPtrGetPtr rgba+    gtk_color_selection_set_current_rgba _obj' rgba'+    touchManagedPtr _obj+    touchManagedPtr rgba+    return ()++-- method ColorSelection::set_has_opacity_control+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_opacity", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_opacity", 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 "gtk_color_selection_set_has_opacity_control" gtk_color_selection_set_has_opacity_control :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    CInt ->                                 -- has_opacity : TBasicType TBoolean+    IO ()+++colorSelectionSetHasOpacityControl ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_opacity+    m ()+colorSelectionSetHasOpacityControl _obj has_opacity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_opacity' = (fromIntegral . fromEnum) has_opacity+    gtk_color_selection_set_has_opacity_control _obj' has_opacity'+    touchManagedPtr _obj+    return ()++-- method ColorSelection::set_has_palette+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_palette", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_palette", 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 "gtk_color_selection_set_has_palette" gtk_color_selection_set_has_palette :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    CInt ->                                 -- has_palette : TBasicType TBoolean+    IO ()+++colorSelectionSetHasPalette ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_palette+    m ()+colorSelectionSetHasPalette _obj has_palette = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_palette' = (fromIntegral . fromEnum) has_palette+    gtk_color_selection_set_has_palette _obj' has_palette'+    touchManagedPtr _obj+    return ()++-- method ColorSelection::set_previous_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_previous_alpha" gtk_color_selection_set_previous_alpha :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Word16 ->                               -- alpha : TBasicType TUInt16+    IO ()+++colorSelectionSetPreviousAlpha ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Word16 ->                               -- alpha+    m ()+colorSelectionSetPreviousAlpha _obj alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_color_selection_set_previous_alpha _obj' alpha+    touchManagedPtr _obj+    return ()++-- method ColorSelection::set_previous_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Gdk" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_previous_color" gtk_color_selection_set_previous_color :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.Color ->                        -- color : TInterface "Gdk" "Color"+    IO ()++{-# DEPRECATED colorSelectionSetPreviousColor ["(Since version 3.4)","Use gtk_color_selection_set_previous_rgba() instead."]#-}+colorSelectionSetPreviousColor ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Gdk.Color ->                            -- color+    m ()+colorSelectionSetPreviousColor _obj color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let color' = unsafeManagedPtrGetPtr color+    gtk_color_selection_set_previous_color _obj' color'+    touchManagedPtr _obj+    touchManagedPtr color+    return ()++-- method ColorSelection::set_previous_rgba+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rgba", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_set_previous_rgba" gtk_color_selection_set_previous_rgba :: +    Ptr ColorSelection ->                   -- _obj : TInterface "Gtk" "ColorSelection"+    Ptr Gdk.RGBA ->                         -- rgba : TInterface "Gdk" "RGBA"+    IO ()+++colorSelectionSetPreviousRgba ::+    (MonadIO m, ColorSelectionK a) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- rgba+    m ()+colorSelectionSetPreviousRgba _obj rgba = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let rgba' = unsafeManagedPtrGetPtr rgba+    gtk_color_selection_set_previous_rgba _obj' rgba'+    touchManagedPtr _obj+    touchManagedPtr rgba+    return ()++-- method ColorSelection::palette_from_string+-- method type : MemberFunction+-- Args : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors", argType = TCArray False (-1) 2 (TInterface "Gdk" "Color"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "str", 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 "gtk_color_selection_palette_from_string" gtk_color_selection_palette_from_string :: +    CString ->                              -- str : TBasicType TUTF8+    Ptr (Ptr Gdk.Color) ->                  -- colors : TCArray False (-1) 2 (TInterface "Gdk" "Color")+    Ptr Int32 ->                            -- n_colors : TBasicType TInt32+    IO CInt+++colorSelectionPaletteFromString ::+    (MonadIO m) =>+    T.Text ->                               -- str+    m (Bool,[Gdk.Color])+colorSelectionPaletteFromString str = liftIO $ do+    str' <- textToCString str+    colors <- allocMem :: IO (Ptr (Ptr Gdk.Color))+    n_colors <- allocMem :: IO (Ptr Int32)+    result <- gtk_color_selection_palette_from_string str' colors n_colors+    n_colors' <- peek n_colors+    let result' = (/= 0) result+    colors' <- peek colors+    colors'' <- (unpackBoxedArrayWithLength 12 n_colors') colors'+    colors''' <- mapM (wrapBoxed Gdk.Color) colors''+    freeMem colors'+    freeMem str'+    freeMem colors+    freeMem n_colors+    return (result', colors''')++-- method ColorSelection::palette_to_string+-- method type : MemberFunction+-- Args : [Arg {argName = "colors", argType = TCArray False (-1) 1 (TInterface "Gdk" "Color"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_colors", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "colors", argType = TCArray False (-1) 1 (TInterface "Gdk" "Color"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_palette_to_string" gtk_color_selection_palette_to_string :: +    Ptr Gdk.Color ->                        -- colors : TCArray False (-1) 1 (TInterface "Gdk" "Color")+    Int32 ->                                -- n_colors : TBasicType TInt32+    IO CString+++colorSelectionPaletteToString ::+    (MonadIO m) =>+    [Gdk.Color] ->                          -- colors+    m T.Text+colorSelectionPaletteToString colors = liftIO $ do+    let n_colors = fromIntegral $ length colors+    let colors' = map unsafeManagedPtrGetPtr colors+    colors'' <- packBlockArray 12 colors'+    result <- gtk_color_selection_palette_to_string colors'' n_colors+    checkUnexpectedReturnNULL "gtk_color_selection_palette_to_string" result+    result' <- cstringToText result+    freeMem result+    mapM_ touchManagedPtr colors+    freeMem colors''+    return result'++
+ GI/Gtk/Objects/ColorSelection.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.ColorSelection where++import Prelude ()+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 ColorSelection = ColorSelection (ForeignPtr ColorSelection)+instance GObject ColorSelection where+class GObject o => ColorSelectionK o+instance (GObject o, IsDescendantOf ColorSelection o) => ColorSelectionK o+data ColorSelectionCurrentAlphaPropertyInfo+data ColorSelectionCurrentColorPropertyInfo+data ColorSelectionCurrentRgbaPropertyInfo+data ColorSelectionHasOpacityControlPropertyInfo+data ColorSelectionHasPalettePropertyInfo+data ColorSelectionColorChangedSignalInfo
+ GI/Gtk/Objects/ColorSelectionDialog.hs view
@@ -0,0 +1,217 @@++{- |+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.Gtk.Objects.ColorSelectionDialog+    ( ++-- * Exported types+    ColorSelectionDialog(..)                ,+    ColorSelectionDialogK                   ,+    toColorSelectionDialog                  ,+    noColorSelectionDialog                  ,+++ -- * Methods+-- ** colorSelectionDialogGetColorSelection+    colorSelectionDialogGetColorSelection   ,+++-- ** colorSelectionDialogNew+    colorSelectionDialogNew                 ,+++++ -- * Properties+-- ** CancelButton+    ColorSelectionDialogCancelButtonPropertyInfo,+    getColorSelectionDialogCancelButton     ,+++-- ** ColorSelection+    ColorSelectionDialogColorSelectionPropertyInfo,+    getColorSelectionDialogColorSelection   ,+++-- ** HelpButton+    ColorSelectionDialogHelpButtonPropertyInfo,+    getColorSelectionDialogHelpButton       ,+++-- ** OkButton+    ColorSelectionDialogOkButtonPropertyInfo,+    getColorSelectionDialogOkButton         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ColorSelectionDialog = ColorSelectionDialog (ForeignPtr ColorSelectionDialog)+foreign import ccall "gtk_color_selection_dialog_get_type"+    c_gtk_color_selection_dialog_get_type :: IO GType++type instance ParentTypes ColorSelectionDialog = ColorSelectionDialogParentTypes+type ColorSelectionDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject ColorSelectionDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_color_selection_dialog_get_type+    ++class GObject o => ColorSelectionDialogK o+instance (GObject o, IsDescendantOf ColorSelectionDialog o) => ColorSelectionDialogK o++toColorSelectionDialog :: ColorSelectionDialogK o => o -> IO ColorSelectionDialog+toColorSelectionDialog = unsafeCastTo ColorSelectionDialog++noColorSelectionDialog :: Maybe ColorSelectionDialog+noColorSelectionDialog = Nothing++-- VVV Prop "cancel-button"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable]++getColorSelectionDialogCancelButton :: (MonadIO m, ColorSelectionDialogK o) => o -> m Widget+getColorSelectionDialogCancelButton obj = liftIO $ getObjectPropertyObject obj "cancel-button" Widget++data ColorSelectionDialogCancelButtonPropertyInfo+instance AttrInfo ColorSelectionDialogCancelButtonPropertyInfo where+    type AttrAllowedOps ColorSelectionDialogCancelButtonPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionDialogCancelButtonPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ColorSelectionDialogCancelButtonPropertyInfo = ColorSelectionDialogK+    type AttrGetType ColorSelectionDialogCancelButtonPropertyInfo = Widget+    type AttrLabel ColorSelectionDialogCancelButtonPropertyInfo = "ColorSelectionDialog::cancel-button"+    attrGet _ = getColorSelectionDialogCancelButton+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "color-selection"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable]++getColorSelectionDialogColorSelection :: (MonadIO m, ColorSelectionDialogK o) => o -> m Widget+getColorSelectionDialogColorSelection obj = liftIO $ getObjectPropertyObject obj "color-selection" Widget++data ColorSelectionDialogColorSelectionPropertyInfo+instance AttrInfo ColorSelectionDialogColorSelectionPropertyInfo where+    type AttrAllowedOps ColorSelectionDialogColorSelectionPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionDialogColorSelectionPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ColorSelectionDialogColorSelectionPropertyInfo = ColorSelectionDialogK+    type AttrGetType ColorSelectionDialogColorSelectionPropertyInfo = Widget+    type AttrLabel ColorSelectionDialogColorSelectionPropertyInfo = "ColorSelectionDialog::color-selection"+    attrGet _ = getColorSelectionDialogColorSelection+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "help-button"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable]++getColorSelectionDialogHelpButton :: (MonadIO m, ColorSelectionDialogK o) => o -> m Widget+getColorSelectionDialogHelpButton obj = liftIO $ getObjectPropertyObject obj "help-button" Widget++data ColorSelectionDialogHelpButtonPropertyInfo+instance AttrInfo ColorSelectionDialogHelpButtonPropertyInfo where+    type AttrAllowedOps ColorSelectionDialogHelpButtonPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionDialogHelpButtonPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ColorSelectionDialogHelpButtonPropertyInfo = ColorSelectionDialogK+    type AttrGetType ColorSelectionDialogHelpButtonPropertyInfo = Widget+    type AttrLabel ColorSelectionDialogHelpButtonPropertyInfo = "ColorSelectionDialog::help-button"+    attrGet _ = getColorSelectionDialogHelpButton+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "ok-button"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable]++getColorSelectionDialogOkButton :: (MonadIO m, ColorSelectionDialogK o) => o -> m Widget+getColorSelectionDialogOkButton obj = liftIO $ getObjectPropertyObject obj "ok-button" Widget++data ColorSelectionDialogOkButtonPropertyInfo+instance AttrInfo ColorSelectionDialogOkButtonPropertyInfo where+    type AttrAllowedOps ColorSelectionDialogOkButtonPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ColorSelectionDialogOkButtonPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ColorSelectionDialogOkButtonPropertyInfo = ColorSelectionDialogK+    type AttrGetType ColorSelectionDialogOkButtonPropertyInfo = Widget+    type AttrLabel ColorSelectionDialogOkButtonPropertyInfo = "ColorSelectionDialog::ok-button"+    attrGet _ = getColorSelectionDialogOkButton+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList ColorSelectionDialog = ColorSelectionDialogAttributeList+type ColorSelectionDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cancel-button", ColorSelectionDialogCancelButtonPropertyInfo), '("child", ContainerChildPropertyInfo), '("color-selection", ColorSelectionDialogColorSelectionPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("help-button", ColorSelectionDialogHelpButtonPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("ok-button", ColorSelectionDialogOkButtonPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ColorSelectionDialog = ColorSelectionDialogSignalList+type ColorSelectionDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ColorSelectionDialog::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 "Gtk" "ColorSelectionDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_dialog_new" gtk_color_selection_dialog_new :: +    CString ->                              -- title : TBasicType TUTF8+    IO (Ptr ColorSelectionDialog)+++colorSelectionDialogNew ::+    (MonadIO m) =>+    T.Text ->                               -- title+    m ColorSelectionDialog+colorSelectionDialogNew title = liftIO $ do+    title' <- textToCString title+    result <- gtk_color_selection_dialog_new title'+    checkUnexpectedReturnNULL "gtk_color_selection_dialog_new" result+    result' <- (newObject ColorSelectionDialog) result+    freeMem title'+    return result'++-- method ColorSelectionDialog::get_color_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ColorSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_color_selection_dialog_get_color_selection" gtk_color_selection_dialog_get_color_selection :: +    Ptr ColorSelectionDialog ->             -- _obj : TInterface "Gtk" "ColorSelectionDialog"+    IO (Ptr Widget)+++colorSelectionDialogGetColorSelection ::+    (MonadIO m, ColorSelectionDialogK a) =>+    a ->                                    -- _obj+    m Widget+colorSelectionDialogGetColorSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_color_selection_dialog_get_color_selection _obj'+    checkUnexpectedReturnNULL "gtk_color_selection_dialog_get_color_selection" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/ColorSelectionDialog.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.ColorSelectionDialog where++import Prelude ()+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 ColorSelectionDialog = ColorSelectionDialog (ForeignPtr ColorSelectionDialog)+instance GObject ColorSelectionDialog where+class GObject o => ColorSelectionDialogK o+instance (GObject o, IsDescendantOf ColorSelectionDialog o) => ColorSelectionDialogK o+data ColorSelectionDialogCancelButtonPropertyInfo+data ColorSelectionDialogColorSelectionPropertyInfo+data ColorSelectionDialogHelpButtonPropertyInfo+data ColorSelectionDialogOkButtonPropertyInfo
+ GI/Gtk/Objects/ComboBox.hs view
@@ -0,0 +1,2073 @@++{- |+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.Gtk.Objects.ComboBox+    ( ++-- * Exported types+    ComboBox(..)                            ,+    ComboBoxK                               ,+    toComboBox                              ,+    noComboBox                              ,+++ -- * Methods+-- ** comboBoxGetActive+    comboBoxGetActive                       ,+++-- ** comboBoxGetActiveId+    comboBoxGetActiveId                     ,+++-- ** comboBoxGetActiveIter+    comboBoxGetActiveIter                   ,+++-- ** comboBoxGetAddTearoffs+    comboBoxGetAddTearoffs                  ,+++-- ** comboBoxGetButtonSensitivity+    comboBoxGetButtonSensitivity            ,+++-- ** comboBoxGetColumnSpanColumn+    comboBoxGetColumnSpanColumn             ,+++-- ** comboBoxGetEntryTextColumn+    comboBoxGetEntryTextColumn              ,+++-- ** comboBoxGetFocusOnClick+    comboBoxGetFocusOnClick                 ,+++-- ** comboBoxGetHasEntry+    comboBoxGetHasEntry                     ,+++-- ** comboBoxGetIdColumn+    comboBoxGetIdColumn                     ,+++-- ** comboBoxGetModel+    comboBoxGetModel                        ,+++-- ** comboBoxGetPopupAccessible+    comboBoxGetPopupAccessible              ,+++-- ** comboBoxGetPopupFixedWidth+    comboBoxGetPopupFixedWidth              ,+++-- ** comboBoxGetRowSpanColumn+    comboBoxGetRowSpanColumn                ,+++-- ** comboBoxGetTitle+    comboBoxGetTitle                        ,+++-- ** comboBoxGetWrapWidth+    comboBoxGetWrapWidth                    ,+++-- ** comboBoxNew+    comboBoxNew                             ,+++-- ** comboBoxNewWithArea+    comboBoxNewWithArea                     ,+++-- ** comboBoxNewWithAreaAndEntry+    comboBoxNewWithAreaAndEntry             ,+++-- ** comboBoxNewWithEntry+    comboBoxNewWithEntry                    ,+++-- ** comboBoxNewWithModel+    comboBoxNewWithModel                    ,+++-- ** comboBoxNewWithModelAndEntry+    comboBoxNewWithModelAndEntry            ,+++-- ** comboBoxPopdown+    comboBoxPopdown                         ,+++-- ** comboBoxPopup+    comboBoxPopup                           ,+++-- ** comboBoxPopupForDevice+    comboBoxPopupForDevice                  ,+++-- ** comboBoxSetActive+    comboBoxSetActive                       ,+++-- ** comboBoxSetActiveId+    comboBoxSetActiveId                     ,+++-- ** comboBoxSetActiveIter+    comboBoxSetActiveIter                   ,+++-- ** comboBoxSetAddTearoffs+    comboBoxSetAddTearoffs                  ,+++-- ** comboBoxSetButtonSensitivity+    comboBoxSetButtonSensitivity            ,+++-- ** comboBoxSetColumnSpanColumn+    comboBoxSetColumnSpanColumn             ,+++-- ** comboBoxSetEntryTextColumn+    comboBoxSetEntryTextColumn              ,+++-- ** comboBoxSetFocusOnClick+    comboBoxSetFocusOnClick                 ,+++-- ** comboBoxSetIdColumn+    comboBoxSetIdColumn                     ,+++-- ** comboBoxSetModel+    comboBoxSetModel                        ,+++-- ** comboBoxSetPopupFixedWidth+    comboBoxSetPopupFixedWidth              ,+++-- ** comboBoxSetRowSeparatorFunc+    comboBoxSetRowSeparatorFunc             ,+++-- ** comboBoxSetRowSpanColumn+    comboBoxSetRowSpanColumn                ,+++-- ** comboBoxSetTitle+    comboBoxSetTitle                        ,+++-- ** comboBoxSetWrapWidth+    comboBoxSetWrapWidth                    ,+++++ -- * Properties+-- ** Active+    ComboBoxActivePropertyInfo              ,+    constructComboBoxActive                 ,+    getComboBoxActive                       ,+    setComboBoxActive                       ,+++-- ** ActiveId+    ComboBoxActiveIdPropertyInfo            ,+    constructComboBoxActiveId               ,+    getComboBoxActiveId                     ,+    setComboBoxActiveId                     ,+++-- ** AddTearoffs+    ComboBoxAddTearoffsPropertyInfo         ,+    constructComboBoxAddTearoffs            ,+    getComboBoxAddTearoffs                  ,+    setComboBoxAddTearoffs                  ,+++-- ** ButtonSensitivity+    ComboBoxButtonSensitivityPropertyInfo   ,+    constructComboBoxButtonSensitivity      ,+    getComboBoxButtonSensitivity            ,+    setComboBoxButtonSensitivity            ,+++-- ** CellArea+    ComboBoxCellAreaPropertyInfo            ,+    constructComboBoxCellArea               ,+    getComboBoxCellArea                     ,+++-- ** ColumnSpanColumn+    ComboBoxColumnSpanColumnPropertyInfo    ,+    constructComboBoxColumnSpanColumn       ,+    getComboBoxColumnSpanColumn             ,+    setComboBoxColumnSpanColumn             ,+++-- ** EntryTextColumn+    ComboBoxEntryTextColumnPropertyInfo     ,+    constructComboBoxEntryTextColumn        ,+    getComboBoxEntryTextColumn              ,+    setComboBoxEntryTextColumn              ,+++-- ** FocusOnClick+    ComboBoxFocusOnClickPropertyInfo        ,+    constructComboBoxFocusOnClick           ,+    getComboBoxFocusOnClick                 ,+    setComboBoxFocusOnClick                 ,+++-- ** HasEntry+    ComboBoxHasEntryPropertyInfo            ,+    constructComboBoxHasEntry               ,+    getComboBoxHasEntry                     ,+++-- ** HasFrame+    ComboBoxHasFramePropertyInfo            ,+    constructComboBoxHasFrame               ,+    getComboBoxHasFrame                     ,+    setComboBoxHasFrame                     ,+++-- ** IdColumn+    ComboBoxIdColumnPropertyInfo            ,+    constructComboBoxIdColumn               ,+    getComboBoxIdColumn                     ,+    setComboBoxIdColumn                     ,+++-- ** Model+    ComboBoxModelPropertyInfo               ,+    constructComboBoxModel                  ,+    getComboBoxModel                        ,+    setComboBoxModel                        ,+++-- ** PopupFixedWidth+    ComboBoxPopupFixedWidthPropertyInfo     ,+    constructComboBoxPopupFixedWidth        ,+    getComboBoxPopupFixedWidth              ,+    setComboBoxPopupFixedWidth              ,+++-- ** PopupShown+    ComboBoxPopupShownPropertyInfo          ,+    getComboBoxPopupShown                   ,+++-- ** RowSpanColumn+    ComboBoxRowSpanColumnPropertyInfo       ,+    constructComboBoxRowSpanColumn          ,+    getComboBoxRowSpanColumn                ,+    setComboBoxRowSpanColumn                ,+++-- ** TearoffTitle+    ComboBoxTearoffTitlePropertyInfo        ,+    constructComboBoxTearoffTitle           ,+    getComboBoxTearoffTitle                 ,+    setComboBoxTearoffTitle                 ,+++-- ** WrapWidth+    ComboBoxWrapWidthPropertyInfo           ,+    constructComboBoxWrapWidth              ,+    getComboBoxWrapWidth                    ,+    setComboBoxWrapWidth                    ,+++++ -- * Signals+-- ** Changed+    ComboBoxChangedCallback                 ,+    ComboBoxChangedCallbackC                ,+    ComboBoxChangedSignalInfo               ,+    afterComboBoxChanged                    ,+    comboBoxChangedCallbackWrapper          ,+    comboBoxChangedClosure                  ,+    mkComboBoxChangedCallback               ,+    noComboBoxChangedCallback               ,+    onComboBoxChanged                       ,+++-- ** FormatEntryText+    ComboBoxFormatEntryTextCallback         ,+    ComboBoxFormatEntryTextCallbackC        ,+    ComboBoxFormatEntryTextSignalInfo       ,+    afterComboBoxFormatEntryText            ,+    comboBoxFormatEntryTextCallbackWrapper  ,+    comboBoxFormatEntryTextClosure          ,+    mkComboBoxFormatEntryTextCallback       ,+    noComboBoxFormatEntryTextCallback       ,+    onComboBoxFormatEntryText               ,+++-- ** MoveActive+    ComboBoxMoveActiveCallback              ,+    ComboBoxMoveActiveCallbackC             ,+    ComboBoxMoveActiveSignalInfo            ,+    afterComboBoxMoveActive                 ,+    comboBoxMoveActiveCallbackWrapper       ,+    comboBoxMoveActiveClosure               ,+    mkComboBoxMoveActiveCallback            ,+    noComboBoxMoveActiveCallback            ,+    onComboBoxMoveActive                    ,+++-- ** Popdown+    ComboBoxPopdownCallback                 ,+    ComboBoxPopdownCallbackC                ,+    ComboBoxPopdownSignalInfo               ,+    afterComboBoxPopdown                    ,+    comboBoxPopdownCallbackWrapper          ,+    comboBoxPopdownClosure                  ,+    mkComboBoxPopdownCallback               ,+    noComboBoxPopdownCallback               ,+    onComboBoxPopdown                       ,+++-- ** Popup+    ComboBoxPopupCallback                   ,+    ComboBoxPopupCallbackC                  ,+    ComboBoxPopupSignalInfo                 ,+    afterComboBoxPopup                      ,+    comboBoxPopupCallbackWrapper            ,+    comboBoxPopupClosure                    ,+    mkComboBoxPopupCallback                 ,+    noComboBoxPopupCallback                 ,+    onComboBoxPopup                         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype ComboBox = ComboBox (ForeignPtr ComboBox)+foreign import ccall "gtk_combo_box_get_type"+    c_gtk_combo_box_get_type :: IO GType++type instance ParentTypes ComboBox = ComboBoxParentTypes+type ComboBoxParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, CellEditable, CellLayout]++instance GObject ComboBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_combo_box_get_type+    ++class GObject o => ComboBoxK o+instance (GObject o, IsDescendantOf ComboBox o) => ComboBoxK o++toComboBox :: ComboBoxK o => o -> IO ComboBox+toComboBox = unsafeCastTo ComboBox++noComboBox :: Maybe ComboBox+noComboBox = Nothing++-- signal ComboBox::changed+type ComboBoxChangedCallback =+    IO ()++noComboBoxChangedCallback :: Maybe ComboBoxChangedCallback+noComboBoxChangedCallback = Nothing++type ComboBoxChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkComboBoxChangedCallback :: ComboBoxChangedCallbackC -> IO (FunPtr ComboBoxChangedCallbackC)++comboBoxChangedClosure :: ComboBoxChangedCallback -> IO Closure+comboBoxChangedClosure cb = newCClosure =<< mkComboBoxChangedCallback wrapped+    where wrapped = comboBoxChangedCallbackWrapper cb++comboBoxChangedCallbackWrapper ::+    ComboBoxChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+comboBoxChangedCallbackWrapper _cb _ _ = do+    _cb ++onComboBoxChanged :: (GObject a, MonadIO m) => a -> ComboBoxChangedCallback -> m SignalHandlerId+onComboBoxChanged obj cb = liftIO $ connectComboBoxChanged obj cb SignalConnectBefore+afterComboBoxChanged :: (GObject a, MonadIO m) => a -> ComboBoxChangedCallback -> m SignalHandlerId+afterComboBoxChanged obj cb = connectComboBoxChanged obj cb SignalConnectAfter++connectComboBoxChanged :: (GObject a, MonadIO m) =>+                          a -> ComboBoxChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectComboBoxChanged obj cb after = liftIO $ do+    cb' <- mkComboBoxChangedCallback (comboBoxChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal ComboBox::format-entry-text+type ComboBoxFormatEntryTextCallback =+    T.Text ->+    IO T.Text++noComboBoxFormatEntryTextCallback :: Maybe ComboBoxFormatEntryTextCallback+noComboBoxFormatEntryTextCallback = Nothing++type ComboBoxFormatEntryTextCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO CString++foreign import ccall "wrapper"+    mkComboBoxFormatEntryTextCallback :: ComboBoxFormatEntryTextCallbackC -> IO (FunPtr ComboBoxFormatEntryTextCallbackC)++comboBoxFormatEntryTextClosure :: ComboBoxFormatEntryTextCallback -> IO Closure+comboBoxFormatEntryTextClosure cb = newCClosure =<< mkComboBoxFormatEntryTextCallback wrapped+    where wrapped = comboBoxFormatEntryTextCallbackWrapper cb++comboBoxFormatEntryTextCallbackWrapper ::+    ComboBoxFormatEntryTextCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO CString+comboBoxFormatEntryTextCallbackWrapper _cb _ path _ = do+    path' <- cstringToText path+    result <- _cb  path'+    result' <- textToCString result+    return result'++onComboBoxFormatEntryText :: (GObject a, MonadIO m) => a -> ComboBoxFormatEntryTextCallback -> m SignalHandlerId+onComboBoxFormatEntryText obj cb = liftIO $ connectComboBoxFormatEntryText obj cb SignalConnectBefore+afterComboBoxFormatEntryText :: (GObject a, MonadIO m) => a -> ComboBoxFormatEntryTextCallback -> m SignalHandlerId+afterComboBoxFormatEntryText obj cb = connectComboBoxFormatEntryText obj cb SignalConnectAfter++connectComboBoxFormatEntryText :: (GObject a, MonadIO m) =>+                                  a -> ComboBoxFormatEntryTextCallback -> SignalConnectMode -> m SignalHandlerId+connectComboBoxFormatEntryText obj cb after = liftIO $ do+    cb' <- mkComboBoxFormatEntryTextCallback (comboBoxFormatEntryTextCallbackWrapper cb)+    connectSignalFunPtr obj "format-entry-text" cb' after++-- signal ComboBox::move-active+type ComboBoxMoveActiveCallback =+    ScrollType ->+    IO ()++noComboBoxMoveActiveCallback :: Maybe ComboBoxMoveActiveCallback+noComboBoxMoveActiveCallback = Nothing++type ComboBoxMoveActiveCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkComboBoxMoveActiveCallback :: ComboBoxMoveActiveCallbackC -> IO (FunPtr ComboBoxMoveActiveCallbackC)++comboBoxMoveActiveClosure :: ComboBoxMoveActiveCallback -> IO Closure+comboBoxMoveActiveClosure cb = newCClosure =<< mkComboBoxMoveActiveCallback wrapped+    where wrapped = comboBoxMoveActiveCallbackWrapper cb++comboBoxMoveActiveCallbackWrapper ::+    ComboBoxMoveActiveCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+comboBoxMoveActiveCallbackWrapper _cb _ scroll_type _ = do+    let scroll_type' = (toEnum . fromIntegral) scroll_type+    _cb  scroll_type'++onComboBoxMoveActive :: (GObject a, MonadIO m) => a -> ComboBoxMoveActiveCallback -> m SignalHandlerId+onComboBoxMoveActive obj cb = liftIO $ connectComboBoxMoveActive obj cb SignalConnectBefore+afterComboBoxMoveActive :: (GObject a, MonadIO m) => a -> ComboBoxMoveActiveCallback -> m SignalHandlerId+afterComboBoxMoveActive obj cb = connectComboBoxMoveActive obj cb SignalConnectAfter++connectComboBoxMoveActive :: (GObject a, MonadIO m) =>+                             a -> ComboBoxMoveActiveCallback -> SignalConnectMode -> m SignalHandlerId+connectComboBoxMoveActive obj cb after = liftIO $ do+    cb' <- mkComboBoxMoveActiveCallback (comboBoxMoveActiveCallbackWrapper cb)+    connectSignalFunPtr obj "move-active" cb' after++-- signal ComboBox::popdown+type ComboBoxPopdownCallback =+    IO Bool++noComboBoxPopdownCallback :: Maybe ComboBoxPopdownCallback+noComboBoxPopdownCallback = Nothing++type ComboBoxPopdownCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkComboBoxPopdownCallback :: ComboBoxPopdownCallbackC -> IO (FunPtr ComboBoxPopdownCallbackC)++comboBoxPopdownClosure :: ComboBoxPopdownCallback -> IO Closure+comboBoxPopdownClosure cb = newCClosure =<< mkComboBoxPopdownCallback wrapped+    where wrapped = comboBoxPopdownCallbackWrapper cb++comboBoxPopdownCallbackWrapper ::+    ComboBoxPopdownCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+comboBoxPopdownCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onComboBoxPopdown :: (GObject a, MonadIO m) => a -> ComboBoxPopdownCallback -> m SignalHandlerId+onComboBoxPopdown obj cb = liftIO $ connectComboBoxPopdown obj cb SignalConnectBefore+afterComboBoxPopdown :: (GObject a, MonadIO m) => a -> ComboBoxPopdownCallback -> m SignalHandlerId+afterComboBoxPopdown obj cb = connectComboBoxPopdown obj cb SignalConnectAfter++connectComboBoxPopdown :: (GObject a, MonadIO m) =>+                          a -> ComboBoxPopdownCallback -> SignalConnectMode -> m SignalHandlerId+connectComboBoxPopdown obj cb after = liftIO $ do+    cb' <- mkComboBoxPopdownCallback (comboBoxPopdownCallbackWrapper cb)+    connectSignalFunPtr obj "popdown" cb' after++-- signal ComboBox::popup+type ComboBoxPopupCallback =+    IO ()++noComboBoxPopupCallback :: Maybe ComboBoxPopupCallback+noComboBoxPopupCallback = Nothing++type ComboBoxPopupCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkComboBoxPopupCallback :: ComboBoxPopupCallbackC -> IO (FunPtr ComboBoxPopupCallbackC)++comboBoxPopupClosure :: ComboBoxPopupCallback -> IO Closure+comboBoxPopupClosure cb = newCClosure =<< mkComboBoxPopupCallback wrapped+    where wrapped = comboBoxPopupCallbackWrapper cb++comboBoxPopupCallbackWrapper ::+    ComboBoxPopupCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+comboBoxPopupCallbackWrapper _cb _ _ = do+    _cb ++onComboBoxPopup :: (GObject a, MonadIO m) => a -> ComboBoxPopupCallback -> m SignalHandlerId+onComboBoxPopup obj cb = liftIO $ connectComboBoxPopup obj cb SignalConnectBefore+afterComboBoxPopup :: (GObject a, MonadIO m) => a -> ComboBoxPopupCallback -> m SignalHandlerId+afterComboBoxPopup obj cb = connectComboBoxPopup obj cb SignalConnectAfter++connectComboBoxPopup :: (GObject a, MonadIO m) =>+                        a -> ComboBoxPopupCallback -> SignalConnectMode -> m SignalHandlerId+connectComboBoxPopup obj cb after = liftIO $ do+    cb' <- mkComboBoxPopupCallback (comboBoxPopupCallbackWrapper cb)+    connectSignalFunPtr obj "popup" cb' after++-- VVV Prop "active"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxActive :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxActive obj = liftIO $ getObjectPropertyCInt obj "active"++setComboBoxActive :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxActive obj val = liftIO $ setObjectPropertyCInt obj "active" val++constructComboBoxActive :: Int32 -> IO ([Char], GValue)+constructComboBoxActive val = constructObjectPropertyCInt "active" val++data ComboBoxActivePropertyInfo+instance AttrInfo ComboBoxActivePropertyInfo where+    type AttrAllowedOps ComboBoxActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxActivePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxActivePropertyInfo = ComboBoxK+    type AttrGetType ComboBoxActivePropertyInfo = Int32+    type AttrLabel ComboBoxActivePropertyInfo = "ComboBox::active"+    attrGet _ = getComboBoxActive+    attrSet _ = setComboBoxActive+    attrConstruct _ = constructComboBoxActive++-- VVV Prop "active-id"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxActiveId :: (MonadIO m, ComboBoxK o) => o -> m T.Text+getComboBoxActiveId obj = liftIO $ getObjectPropertyString obj "active-id"++setComboBoxActiveId :: (MonadIO m, ComboBoxK o) => o -> T.Text -> m ()+setComboBoxActiveId obj val = liftIO $ setObjectPropertyString obj "active-id" val++constructComboBoxActiveId :: T.Text -> IO ([Char], GValue)+constructComboBoxActiveId val = constructObjectPropertyString "active-id" val++data ComboBoxActiveIdPropertyInfo+instance AttrInfo ComboBoxActiveIdPropertyInfo where+    type AttrAllowedOps ComboBoxActiveIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxActiveIdPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ComboBoxActiveIdPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxActiveIdPropertyInfo = T.Text+    type AttrLabel ComboBoxActiveIdPropertyInfo = "ComboBox::active-id"+    attrGet _ = getComboBoxActiveId+    attrSet _ = setComboBoxActiveId+    attrConstruct _ = constructComboBoxActiveId++-- VVV Prop "add-tearoffs"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxAddTearoffs :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxAddTearoffs obj = liftIO $ getObjectPropertyBool obj "add-tearoffs"++setComboBoxAddTearoffs :: (MonadIO m, ComboBoxK o) => o -> Bool -> m ()+setComboBoxAddTearoffs obj val = liftIO $ setObjectPropertyBool obj "add-tearoffs" val++constructComboBoxAddTearoffs :: Bool -> IO ([Char], GValue)+constructComboBoxAddTearoffs val = constructObjectPropertyBool "add-tearoffs" val++data ComboBoxAddTearoffsPropertyInfo+instance AttrInfo ComboBoxAddTearoffsPropertyInfo where+    type AttrAllowedOps ComboBoxAddTearoffsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxAddTearoffsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ComboBoxAddTearoffsPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxAddTearoffsPropertyInfo = Bool+    type AttrLabel ComboBoxAddTearoffsPropertyInfo = "ComboBox::add-tearoffs"+    attrGet _ = getComboBoxAddTearoffs+    attrSet _ = setComboBoxAddTearoffs+    attrConstruct _ = constructComboBoxAddTearoffs++-- VVV Prop "button-sensitivity"+   -- Type: TInterface "Gtk" "SensitivityType"+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxButtonSensitivity :: (MonadIO m, ComboBoxK o) => o -> m SensitivityType+getComboBoxButtonSensitivity obj = liftIO $ getObjectPropertyEnum obj "button-sensitivity"++setComboBoxButtonSensitivity :: (MonadIO m, ComboBoxK o) => o -> SensitivityType -> m ()+setComboBoxButtonSensitivity obj val = liftIO $ setObjectPropertyEnum obj "button-sensitivity" val++constructComboBoxButtonSensitivity :: SensitivityType -> IO ([Char], GValue)+constructComboBoxButtonSensitivity val = constructObjectPropertyEnum "button-sensitivity" val++data ComboBoxButtonSensitivityPropertyInfo+instance AttrInfo ComboBoxButtonSensitivityPropertyInfo where+    type AttrAllowedOps ComboBoxButtonSensitivityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxButtonSensitivityPropertyInfo = (~) SensitivityType+    type AttrBaseTypeConstraint ComboBoxButtonSensitivityPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxButtonSensitivityPropertyInfo = SensitivityType+    type AttrLabel ComboBoxButtonSensitivityPropertyInfo = "ComboBox::button-sensitivity"+    attrGet _ = getComboBoxButtonSensitivity+    attrSet _ = setComboBoxButtonSensitivity+    attrConstruct _ = constructComboBoxButtonSensitivity++-- VVV Prop "cell-area"+   -- Type: TInterface "Gtk" "CellArea"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getComboBoxCellArea :: (MonadIO m, ComboBoxK o) => o -> m CellArea+getComboBoxCellArea obj = liftIO $ getObjectPropertyObject obj "cell-area" CellArea++constructComboBoxCellArea :: (CellAreaK a) => a -> IO ([Char], GValue)+constructComboBoxCellArea val = constructObjectPropertyObject "cell-area" val++data ComboBoxCellAreaPropertyInfo+instance AttrInfo ComboBoxCellAreaPropertyInfo where+    type AttrAllowedOps ComboBoxCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxCellAreaPropertyInfo = CellAreaK+    type AttrBaseTypeConstraint ComboBoxCellAreaPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxCellAreaPropertyInfo = CellArea+    type AttrLabel ComboBoxCellAreaPropertyInfo = "ComboBox::cell-area"+    attrGet _ = getComboBoxCellArea+    attrSet _ = undefined+    attrConstruct _ = constructComboBoxCellArea++-- VVV Prop "column-span-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxColumnSpanColumn :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxColumnSpanColumn obj = liftIO $ getObjectPropertyCInt obj "column-span-column"++setComboBoxColumnSpanColumn :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxColumnSpanColumn obj val = liftIO $ setObjectPropertyCInt obj "column-span-column" val++constructComboBoxColumnSpanColumn :: Int32 -> IO ([Char], GValue)+constructComboBoxColumnSpanColumn val = constructObjectPropertyCInt "column-span-column" val++data ComboBoxColumnSpanColumnPropertyInfo+instance AttrInfo ComboBoxColumnSpanColumnPropertyInfo where+    type AttrAllowedOps ComboBoxColumnSpanColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxColumnSpanColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxColumnSpanColumnPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxColumnSpanColumnPropertyInfo = Int32+    type AttrLabel ComboBoxColumnSpanColumnPropertyInfo = "ComboBox::column-span-column"+    attrGet _ = getComboBoxColumnSpanColumn+    attrSet _ = setComboBoxColumnSpanColumn+    attrConstruct _ = constructComboBoxColumnSpanColumn++-- VVV Prop "entry-text-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxEntryTextColumn :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxEntryTextColumn obj = liftIO $ getObjectPropertyCInt obj "entry-text-column"++setComboBoxEntryTextColumn :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxEntryTextColumn obj val = liftIO $ setObjectPropertyCInt obj "entry-text-column" val++constructComboBoxEntryTextColumn :: Int32 -> IO ([Char], GValue)+constructComboBoxEntryTextColumn val = constructObjectPropertyCInt "entry-text-column" val++data ComboBoxEntryTextColumnPropertyInfo+instance AttrInfo ComboBoxEntryTextColumnPropertyInfo where+    type AttrAllowedOps ComboBoxEntryTextColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxEntryTextColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxEntryTextColumnPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxEntryTextColumnPropertyInfo = Int32+    type AttrLabel ComboBoxEntryTextColumnPropertyInfo = "ComboBox::entry-text-column"+    attrGet _ = getComboBoxEntryTextColumn+    attrSet _ = setComboBoxEntryTextColumn+    attrConstruct _ = constructComboBoxEntryTextColumn++-- VVV Prop "focus-on-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxFocusOnClick :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxFocusOnClick obj = liftIO $ getObjectPropertyBool obj "focus-on-click"++setComboBoxFocusOnClick :: (MonadIO m, ComboBoxK o) => o -> Bool -> m ()+setComboBoxFocusOnClick obj val = liftIO $ setObjectPropertyBool obj "focus-on-click" val++constructComboBoxFocusOnClick :: Bool -> IO ([Char], GValue)+constructComboBoxFocusOnClick val = constructObjectPropertyBool "focus-on-click" val++data ComboBoxFocusOnClickPropertyInfo+instance AttrInfo ComboBoxFocusOnClickPropertyInfo where+    type AttrAllowedOps ComboBoxFocusOnClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxFocusOnClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ComboBoxFocusOnClickPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxFocusOnClickPropertyInfo = Bool+    type AttrLabel ComboBoxFocusOnClickPropertyInfo = "ComboBox::focus-on-click"+    attrGet _ = getComboBoxFocusOnClick+    attrSet _ = setComboBoxFocusOnClick+    attrConstruct _ = constructComboBoxFocusOnClick++-- VVV Prop "has-entry"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getComboBoxHasEntry :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxHasEntry obj = liftIO $ getObjectPropertyBool obj "has-entry"++constructComboBoxHasEntry :: Bool -> IO ([Char], GValue)+constructComboBoxHasEntry val = constructObjectPropertyBool "has-entry" val++data ComboBoxHasEntryPropertyInfo+instance AttrInfo ComboBoxHasEntryPropertyInfo where+    type AttrAllowedOps ComboBoxHasEntryPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxHasEntryPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ComboBoxHasEntryPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxHasEntryPropertyInfo = Bool+    type AttrLabel ComboBoxHasEntryPropertyInfo = "ComboBox::has-entry"+    attrGet _ = getComboBoxHasEntry+    attrSet _ = undefined+    attrConstruct _ = constructComboBoxHasEntry++-- VVV Prop "has-frame"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxHasFrame :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxHasFrame obj = liftIO $ getObjectPropertyBool obj "has-frame"++setComboBoxHasFrame :: (MonadIO m, ComboBoxK o) => o -> Bool -> m ()+setComboBoxHasFrame obj val = liftIO $ setObjectPropertyBool obj "has-frame" val++constructComboBoxHasFrame :: Bool -> IO ([Char], GValue)+constructComboBoxHasFrame val = constructObjectPropertyBool "has-frame" val++data ComboBoxHasFramePropertyInfo+instance AttrInfo ComboBoxHasFramePropertyInfo where+    type AttrAllowedOps ComboBoxHasFramePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxHasFramePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ComboBoxHasFramePropertyInfo = ComboBoxK+    type AttrGetType ComboBoxHasFramePropertyInfo = Bool+    type AttrLabel ComboBoxHasFramePropertyInfo = "ComboBox::has-frame"+    attrGet _ = getComboBoxHasFrame+    attrSet _ = setComboBoxHasFrame+    attrConstruct _ = constructComboBoxHasFrame++-- VVV Prop "id-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxIdColumn :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxIdColumn obj = liftIO $ getObjectPropertyCInt obj "id-column"++setComboBoxIdColumn :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxIdColumn obj val = liftIO $ setObjectPropertyCInt obj "id-column" val++constructComboBoxIdColumn :: Int32 -> IO ([Char], GValue)+constructComboBoxIdColumn val = constructObjectPropertyCInt "id-column" val++data ComboBoxIdColumnPropertyInfo+instance AttrInfo ComboBoxIdColumnPropertyInfo where+    type AttrAllowedOps ComboBoxIdColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxIdColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxIdColumnPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxIdColumnPropertyInfo = Int32+    type AttrLabel ComboBoxIdColumnPropertyInfo = "ComboBox::id-column"+    attrGet _ = getComboBoxIdColumn+    attrSet _ = setComboBoxIdColumn+    attrConstruct _ = constructComboBoxIdColumn++-- VVV Prop "model"+   -- Type: TInterface "Gtk" "TreeModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxModel :: (MonadIO m, ComboBoxK o) => o -> m TreeModel+getComboBoxModel obj = liftIO $ getObjectPropertyObject obj "model" TreeModel++setComboBoxModel :: (MonadIO m, ComboBoxK o, TreeModelK a) => o -> a -> m ()+setComboBoxModel obj val = liftIO $ setObjectPropertyObject obj "model" val++constructComboBoxModel :: (TreeModelK a) => a -> IO ([Char], GValue)+constructComboBoxModel val = constructObjectPropertyObject "model" val++data ComboBoxModelPropertyInfo+instance AttrInfo ComboBoxModelPropertyInfo where+    type AttrAllowedOps ComboBoxModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxModelPropertyInfo = TreeModelK+    type AttrBaseTypeConstraint ComboBoxModelPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxModelPropertyInfo = TreeModel+    type AttrLabel ComboBoxModelPropertyInfo = "ComboBox::model"+    attrGet _ = getComboBoxModel+    attrSet _ = setComboBoxModel+    attrConstruct _ = constructComboBoxModel++-- VVV Prop "popup-fixed-width"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxPopupFixedWidth :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxPopupFixedWidth obj = liftIO $ getObjectPropertyBool obj "popup-fixed-width"++setComboBoxPopupFixedWidth :: (MonadIO m, ComboBoxK o) => o -> Bool -> m ()+setComboBoxPopupFixedWidth obj val = liftIO $ setObjectPropertyBool obj "popup-fixed-width" val++constructComboBoxPopupFixedWidth :: Bool -> IO ([Char], GValue)+constructComboBoxPopupFixedWidth val = constructObjectPropertyBool "popup-fixed-width" val++data ComboBoxPopupFixedWidthPropertyInfo+instance AttrInfo ComboBoxPopupFixedWidthPropertyInfo where+    type AttrAllowedOps ComboBoxPopupFixedWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxPopupFixedWidthPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ComboBoxPopupFixedWidthPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxPopupFixedWidthPropertyInfo = Bool+    type AttrLabel ComboBoxPopupFixedWidthPropertyInfo = "ComboBox::popup-fixed-width"+    attrGet _ = getComboBoxPopupFixedWidth+    attrSet _ = setComboBoxPopupFixedWidth+    attrConstruct _ = constructComboBoxPopupFixedWidth++-- VVV Prop "popup-shown"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getComboBoxPopupShown :: (MonadIO m, ComboBoxK o) => o -> m Bool+getComboBoxPopupShown obj = liftIO $ getObjectPropertyBool obj "popup-shown"++data ComboBoxPopupShownPropertyInfo+instance AttrInfo ComboBoxPopupShownPropertyInfo where+    type AttrAllowedOps ComboBoxPopupShownPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ComboBoxPopupShownPropertyInfo = (~) ()+    type AttrBaseTypeConstraint ComboBoxPopupShownPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxPopupShownPropertyInfo = Bool+    type AttrLabel ComboBoxPopupShownPropertyInfo = "ComboBox::popup-shown"+    attrGet _ = getComboBoxPopupShown+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "row-span-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxRowSpanColumn :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxRowSpanColumn obj = liftIO $ getObjectPropertyCInt obj "row-span-column"++setComboBoxRowSpanColumn :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxRowSpanColumn obj val = liftIO $ setObjectPropertyCInt obj "row-span-column" val++constructComboBoxRowSpanColumn :: Int32 -> IO ([Char], GValue)+constructComboBoxRowSpanColumn val = constructObjectPropertyCInt "row-span-column" val++data ComboBoxRowSpanColumnPropertyInfo+instance AttrInfo ComboBoxRowSpanColumnPropertyInfo where+    type AttrAllowedOps ComboBoxRowSpanColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxRowSpanColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxRowSpanColumnPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxRowSpanColumnPropertyInfo = Int32+    type AttrLabel ComboBoxRowSpanColumnPropertyInfo = "ComboBox::row-span-column"+    attrGet _ = getComboBoxRowSpanColumn+    attrSet _ = setComboBoxRowSpanColumn+    attrConstruct _ = constructComboBoxRowSpanColumn++-- VVV Prop "tearoff-title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxTearoffTitle :: (MonadIO m, ComboBoxK o) => o -> m T.Text+getComboBoxTearoffTitle obj = liftIO $ getObjectPropertyString obj "tearoff-title"++setComboBoxTearoffTitle :: (MonadIO m, ComboBoxK o) => o -> T.Text -> m ()+setComboBoxTearoffTitle obj val = liftIO $ setObjectPropertyString obj "tearoff-title" val++constructComboBoxTearoffTitle :: T.Text -> IO ([Char], GValue)+constructComboBoxTearoffTitle val = constructObjectPropertyString "tearoff-title" val++data ComboBoxTearoffTitlePropertyInfo+instance AttrInfo ComboBoxTearoffTitlePropertyInfo where+    type AttrAllowedOps ComboBoxTearoffTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxTearoffTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ComboBoxTearoffTitlePropertyInfo = ComboBoxK+    type AttrGetType ComboBoxTearoffTitlePropertyInfo = T.Text+    type AttrLabel ComboBoxTearoffTitlePropertyInfo = "ComboBox::tearoff-title"+    attrGet _ = getComboBoxTearoffTitle+    attrSet _ = setComboBoxTearoffTitle+    attrConstruct _ = constructComboBoxTearoffTitle++-- VVV Prop "wrap-width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getComboBoxWrapWidth :: (MonadIO m, ComboBoxK o) => o -> m Int32+getComboBoxWrapWidth obj = liftIO $ getObjectPropertyCInt obj "wrap-width"++setComboBoxWrapWidth :: (MonadIO m, ComboBoxK o) => o -> Int32 -> m ()+setComboBoxWrapWidth obj val = liftIO $ setObjectPropertyCInt obj "wrap-width" val++constructComboBoxWrapWidth :: Int32 -> IO ([Char], GValue)+constructComboBoxWrapWidth val = constructObjectPropertyCInt "wrap-width" val++data ComboBoxWrapWidthPropertyInfo+instance AttrInfo ComboBoxWrapWidthPropertyInfo where+    type AttrAllowedOps ComboBoxWrapWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ComboBoxWrapWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ComboBoxWrapWidthPropertyInfo = ComboBoxK+    type AttrGetType ComboBoxWrapWidthPropertyInfo = Int32+    type AttrLabel ComboBoxWrapWidthPropertyInfo = "ComboBox::wrap-width"+    attrGet _ = getComboBoxWrapWidth+    attrSet _ = setComboBoxWrapWidth+    attrConstruct _ = constructComboBoxWrapWidth++type instance AttributeList ComboBox = ComboBoxAttributeList+type ComboBoxAttributeList = ('[ '("active", ComboBoxActivePropertyInfo), '("active-id", ComboBoxActiveIdPropertyInfo), '("add-tearoffs", ComboBoxAddTearoffsPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("button-sensitivity", ComboBoxButtonSensitivityPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cell-area", ComboBoxCellAreaPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-span-column", ComboBoxColumnSpanColumnPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("editing-canceled", CellEditableEditingCanceledPropertyInfo), '("entry-text-column", ComboBoxEntryTextColumnPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ComboBoxFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-entry", ComboBoxHasEntryPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-frame", ComboBoxHasFramePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("id-column", ComboBoxIdColumnPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("model", ComboBoxModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("popup-fixed-width", ComboBoxPopupFixedWidthPropertyInfo), '("popup-shown", ComboBoxPopupShownPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-span-column", ComboBoxRowSpanColumnPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tearoff-title", ComboBoxTearoffTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("wrap-width", ComboBoxWrapWidthPropertyInfo)] :: [(Symbol, *)])++data ComboBoxChangedSignalInfo+instance SignalInfo ComboBoxChangedSignalInfo where+    type HaskellCallbackType ComboBoxChangedSignalInfo = ComboBoxChangedCallback+    connectSignal _ = connectComboBoxChanged++data ComboBoxFormatEntryTextSignalInfo+instance SignalInfo ComboBoxFormatEntryTextSignalInfo where+    type HaskellCallbackType ComboBoxFormatEntryTextSignalInfo = ComboBoxFormatEntryTextCallback+    connectSignal _ = connectComboBoxFormatEntryText++data ComboBoxMoveActiveSignalInfo+instance SignalInfo ComboBoxMoveActiveSignalInfo where+    type HaskellCallbackType ComboBoxMoveActiveSignalInfo = ComboBoxMoveActiveCallback+    connectSignal _ = connectComboBoxMoveActive++data ComboBoxPopdownSignalInfo+instance SignalInfo ComboBoxPopdownSignalInfo where+    type HaskellCallbackType ComboBoxPopdownSignalInfo = ComboBoxPopdownCallback+    connectSignal _ = connectComboBoxPopdown++data ComboBoxPopupSignalInfo+instance SignalInfo ComboBoxPopupSignalInfo where+    type HaskellCallbackType ComboBoxPopupSignalInfo = ComboBoxPopupCallback+    connectSignal _ = connectComboBoxPopup++type instance SignalList ComboBox = ComboBoxSignalList+type ComboBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("changed", ComboBoxChangedSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("editing-done", CellEditableEditingDoneSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("format-entry-text", ComboBoxFormatEntryTextSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-active", ComboBoxMoveActiveSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popdown", ComboBoxPopdownSignalInfo), '("popup", ComboBoxPopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("remove-widget", CellEditableRemoveWidgetSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ComboBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new" gtk_combo_box_new :: +    IO (Ptr ComboBox)+++comboBoxNew ::+    (MonadIO m) =>+    m ComboBox+comboBoxNew  = liftIO $ do+    result <- gtk_combo_box_new+    checkUnexpectedReturnNULL "gtk_combo_box_new" result+    result' <- (newObject ComboBox) result+    return result'++-- method ComboBox::new_with_area+-- method type : Constructor+-- Args : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new_with_area" gtk_combo_box_new_with_area :: +    Ptr CellArea ->                         -- area : TInterface "Gtk" "CellArea"+    IO (Ptr ComboBox)+++comboBoxNewWithArea ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- area+    m ComboBox+comboBoxNewWithArea area = liftIO $ do+    let area' = unsafeManagedPtrCastPtr area+    result <- gtk_combo_box_new_with_area area'+    checkUnexpectedReturnNULL "gtk_combo_box_new_with_area" result+    result' <- (newObject ComboBox) result+    touchManagedPtr area+    return result'++-- method ComboBox::new_with_area_and_entry+-- method type : Constructor+-- Args : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new_with_area_and_entry" gtk_combo_box_new_with_area_and_entry :: +    Ptr CellArea ->                         -- area : TInterface "Gtk" "CellArea"+    IO (Ptr ComboBox)+++comboBoxNewWithAreaAndEntry ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- area+    m ComboBox+comboBoxNewWithAreaAndEntry area = liftIO $ do+    let area' = unsafeManagedPtrCastPtr area+    result <- gtk_combo_box_new_with_area_and_entry area'+    checkUnexpectedReturnNULL "gtk_combo_box_new_with_area_and_entry" result+    result' <- (newObject ComboBox) result+    touchManagedPtr area+    return result'++-- method ComboBox::new_with_entry+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new_with_entry" gtk_combo_box_new_with_entry :: +    IO (Ptr ComboBox)+++comboBoxNewWithEntry ::+    (MonadIO m) =>+    m ComboBox+comboBoxNewWithEntry  = liftIO $ do+    result <- gtk_combo_box_new_with_entry+    checkUnexpectedReturnNULL "gtk_combo_box_new_with_entry" result+    result' <- (newObject ComboBox) result+    return result'++-- method ComboBox::new_with_model+-- method type : Constructor+-- Args : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new_with_model" gtk_combo_box_new_with_model :: +    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO (Ptr ComboBox)+++comboBoxNewWithModel ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- model+    m ComboBox+comboBoxNewWithModel model = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_combo_box_new_with_model model'+    checkUnexpectedReturnNULL "gtk_combo_box_new_with_model" result+    result' <- (newObject ComboBox) result+    touchManagedPtr model+    return result'++-- method ComboBox::new_with_model_and_entry+-- method type : Constructor+-- Args : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ComboBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_new_with_model_and_entry" gtk_combo_box_new_with_model_and_entry :: +    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO (Ptr ComboBox)+++comboBoxNewWithModelAndEntry ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- model+    m ComboBox+comboBoxNewWithModelAndEntry model = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_combo_box_new_with_model_and_entry model'+    checkUnexpectedReturnNULL "gtk_combo_box_new_with_model_and_entry" result+    result' <- (newObject ComboBox) result+    touchManagedPtr model+    return result'++-- method ComboBox::get_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_active" gtk_combo_box_get_active :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetActive ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_active _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::get_active_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_active_id" gtk_combo_box_get_active_id :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CString+++comboBoxGetActiveId ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m T.Text+comboBoxGetActiveId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_active_id _obj'+    checkUnexpectedReturnNULL "gtk_combo_box_get_active_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_active_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_active_iter" gtk_combo_box_get_active_iter :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++comboBoxGetActiveIter ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m (Bool,TreeIter)+comboBoxGetActiveIter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    result <- gtk_combo_box_get_active_iter _obj' iter+    let result' = (/= 0) result+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    return (result', iter')++-- method ComboBox::get_add_tearoffs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_add_tearoffs" gtk_combo_box_get_add_tearoffs :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CInt++{-# DEPRECATED comboBoxGetAddTearoffs ["(Since version 3.10)"]#-}+comboBoxGetAddTearoffs ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Bool+comboBoxGetAddTearoffs _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_add_tearoffs _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_button_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SensitivityType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_button_sensitivity" gtk_combo_box_get_button_sensitivity :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CUInt+++comboBoxGetButtonSensitivity ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m SensitivityType+comboBoxGetButtonSensitivity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_button_sensitivity _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_column_span_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_column_span_column" gtk_combo_box_get_column_span_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetColumnSpanColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetColumnSpanColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_column_span_column _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::get_entry_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_entry_text_column" gtk_combo_box_get_entry_text_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetEntryTextColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetEntryTextColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_entry_text_column _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::get_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_focus_on_click" gtk_combo_box_get_focus_on_click :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CInt+++comboBoxGetFocusOnClick ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Bool+comboBoxGetFocusOnClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_focus_on_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_has_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_has_entry" gtk_combo_box_get_has_entry :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CInt+++comboBoxGetHasEntry ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Bool+comboBoxGetHasEntry _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_has_entry _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_id_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_id_column" gtk_combo_box_get_id_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetIdColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetIdColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_id_column _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::get_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_model" gtk_combo_box_get_model :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO (Ptr TreeModel)+++comboBoxGetModel ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m TreeModel+comboBoxGetModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_model _obj'+    checkUnexpectedReturnNULL "gtk_combo_box_get_model" result+    result' <- (newObject TreeModel) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_popup_accessible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Atk" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_popup_accessible" gtk_combo_box_get_popup_accessible :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO (Ptr Atk.Object)+++comboBoxGetPopupAccessible ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Atk.Object+comboBoxGetPopupAccessible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_popup_accessible _obj'+    checkUnexpectedReturnNULL "gtk_combo_box_get_popup_accessible" result+    result' <- (newObject Atk.Object) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_popup_fixed_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_popup_fixed_width" gtk_combo_box_get_popup_fixed_width :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CInt+++comboBoxGetPopupFixedWidth ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Bool+comboBoxGetPopupFixedWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_popup_fixed_width _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_row_span_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_row_span_column" gtk_combo_box_get_row_span_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetRowSpanColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetRowSpanColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_row_span_column _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_title" gtk_combo_box_get_title :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO CString++{-# DEPRECATED comboBoxGetTitle ["(Since version 3.10)"]#-}+comboBoxGetTitle ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m T.Text+comboBoxGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_title _obj'+    checkUnexpectedReturnNULL "gtk_combo_box_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ComboBox::get_wrap_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_get_wrap_width" gtk_combo_box_get_wrap_width :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO Int32+++comboBoxGetWrapWidth ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m Int32+comboBoxGetWrapWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_get_wrap_width _obj'+    touchManagedPtr _obj+    return result++-- method ComboBox::popdown+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_popdown" gtk_combo_box_popdown :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO ()+++comboBoxPopdown ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m ()+comboBoxPopdown _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_popdown _obj'+    touchManagedPtr _obj+    return ()++-- method ComboBox::popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_popup" gtk_combo_box_popup :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    IO ()+++comboBoxPopup ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    m ()+comboBoxPopup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_popup _obj'+    touchManagedPtr _obj+    return ()++-- method ComboBox::popup_for_device+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_popup_for_device" gtk_combo_box_popup_for_device :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Ptr Gdk.Device ->                       -- device : TInterface "Gdk" "Device"+    IO ()+++comboBoxPopupForDevice ::+    (MonadIO m, ComboBoxK a, Gdk.DeviceK b) =>+    a ->                                    -- _obj+    b ->                                    -- device+    m ()+comboBoxPopupForDevice _obj device = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let device' = unsafeManagedPtrCastPtr device+    gtk_combo_box_popup_for_device _obj' device'+    touchManagedPtr _obj+    touchManagedPtr device+    return ()++-- method ComboBox::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", 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 "Gtk" "ComboBox", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_set_active" gtk_combo_box_set_active :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- index_ : TBasicType TInt32+    IO ()+++comboBoxSetActive ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    m ()+comboBoxSetActive _obj index_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_active _obj' index_+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_active_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "active_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "active_id", 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 "gtk_combo_box_set_active_id" gtk_combo_box_set_active_id :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CString ->                              -- active_id : TBasicType TUTF8+    IO CInt+++comboBoxSetActiveId ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- active_id+    m Bool+comboBoxSetActiveId _obj active_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeActive_id <- case active_id of+        Nothing -> return nullPtr+        Just jActive_id -> do+            jActive_id' <- textToCString jActive_id+            return jActive_id'+    result <- gtk_combo_box_set_active_id _obj' maybeActive_id+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem maybeActive_id+    return result'++-- method ComboBox::set_active_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_set_active_iter" gtk_combo_box_set_active_iter :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++comboBoxSetActiveIter ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- iter+    m ()+comboBoxSetActiveIter _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIter <- case iter of+        Nothing -> return nullPtr+        Just jIter -> do+            let jIter' = unsafeManagedPtrGetPtr jIter+            return jIter'+    gtk_combo_box_set_active_iter _obj' maybeIter+    touchManagedPtr _obj+    whenJust iter touchManagedPtr+    return ()++-- method ComboBox::set_add_tearoffs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "add_tearoffs", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "add_tearoffs", 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 "gtk_combo_box_set_add_tearoffs" gtk_combo_box_set_add_tearoffs :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CInt ->                                 -- add_tearoffs : TBasicType TBoolean+    IO ()++{-# DEPRECATED comboBoxSetAddTearoffs ["(Since version 3.10)"]#-}+comboBoxSetAddTearoffs ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- add_tearoffs+    m ()+comboBoxSetAddTearoffs _obj add_tearoffs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let add_tearoffs' = (fromIntegral . fromEnum) add_tearoffs+    gtk_combo_box_set_add_tearoffs _obj' add_tearoffs'+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_button_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_set_button_sensitivity" gtk_combo_box_set_button_sensitivity :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CUInt ->                                -- sensitivity : TInterface "Gtk" "SensitivityType"+    IO ()+++comboBoxSetButtonSensitivity ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    SensitivityType ->                      -- sensitivity+    m ()+comboBoxSetButtonSensitivity _obj sensitivity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitivity' = (fromIntegral . fromEnum) sensitivity+    gtk_combo_box_set_button_sensitivity _obj' sensitivity'+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_column_span_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column_span", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column_span", 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 "gtk_combo_box_set_column_span_column" gtk_combo_box_set_column_span_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- column_span : TBasicType TInt32+    IO ()+++comboBoxSetColumnSpanColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column_span+    m ()+comboBoxSetColumnSpanColumn _obj column_span = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_column_span_column _obj' column_span+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_entry_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text_column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text_column", 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 "gtk_combo_box_set_entry_text_column" gtk_combo_box_set_entry_text_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- text_column : TBasicType TInt32+    IO ()+++comboBoxSetEntryTextColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- text_column+    m ()+comboBoxSetEntryTextColumn _obj text_column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_entry_text_column _obj' text_column+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", 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 "gtk_combo_box_set_focus_on_click" gtk_combo_box_set_focus_on_click :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CInt ->                                 -- focus_on_click : TBasicType TBoolean+    IO ()+++comboBoxSetFocusOnClick ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- focus_on_click+    m ()+comboBoxSetFocusOnClick _obj focus_on_click = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let focus_on_click' = (fromIntegral . fromEnum) focus_on_click+    gtk_combo_box_set_focus_on_click _obj' focus_on_click'+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_id_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id_column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id_column", 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 "gtk_combo_box_set_id_column" gtk_combo_box_set_id_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- id_column : TBasicType TInt32+    IO ()+++comboBoxSetIdColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- id_column+    m ()+comboBoxSetIdColumn _obj id_column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_id_column _obj' id_column+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_set_model" gtk_combo_box_set_model :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO ()+++comboBoxSetModel ::+    (MonadIO m, ComboBoxK a, TreeModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    m ()+comboBoxSetModel _obj model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    gtk_combo_box_set_model _obj' maybeModel+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    return ()++-- method ComboBox::set_popup_fixed_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fixed", 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 "gtk_combo_box_set_popup_fixed_width" gtk_combo_box_set_popup_fixed_width :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CInt ->                                 -- fixed : TBasicType TBoolean+    IO ()+++comboBoxSetPopupFixedWidth ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- fixed+    m ()+comboBoxSetPopupFixedWidth _obj fixed = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fixed' = (fromIntegral . fromEnum) fixed+    gtk_combo_box_set_popup_fixed_width _obj' fixed'+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_row_separator_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TreeViewRowSeparatorFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, 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 "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "TreeViewRowSeparatorFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_set_row_separator_func" gtk_combo_box_set_row_separator_func :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    FunPtr TreeViewRowSeparatorFuncC ->     -- func : TInterface "Gtk" "TreeViewRowSeparatorFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++comboBoxSetRowSeparatorFunc ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    TreeViewRowSeparatorFunc ->             -- func+    m ()+comboBoxSetRowSeparatorFunc _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkTreeViewRowSeparatorFunc (treeViewRowSeparatorFuncWrapper Nothing func)+    let data_ = castFunPtrToPtr func'+    let destroy = safeFreeFunPtrPtr+    gtk_combo_box_set_row_separator_func _obj' func' data_ destroy+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_row_span_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_span", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_span", 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 "gtk_combo_box_set_row_span_column" gtk_combo_box_set_row_span_column :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- row_span : TBasicType TInt32+    IO ()+++comboBoxSetRowSpanColumn ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- row_span+    m ()+comboBoxSetRowSpanColumn _obj row_span = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_row_span_column _obj' row_span+    touchManagedPtr _obj+    return ()++-- method ComboBox::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", 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 "Gtk" "ComboBox", 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 "gtk_combo_box_set_title" gtk_combo_box_set_title :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    CString ->                              -- title : TBasicType TUTF8+    IO ()++{-# DEPRECATED comboBoxSetTitle ["(Since version 3.10)"]#-}+comboBoxSetTitle ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+comboBoxSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    gtk_combo_box_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method ComboBox::set_wrap_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", 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 "gtk_combo_box_set_wrap_width" gtk_combo_box_set_wrap_width :: +    Ptr ComboBox ->                         -- _obj : TInterface "Gtk" "ComboBox"+    Int32 ->                                -- width : TBasicType TInt32+    IO ()+++comboBoxSetWrapWidth ::+    (MonadIO m, ComboBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- width+    m ()+comboBoxSetWrapWidth _obj width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_set_wrap_width _obj' width+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ComboBox.hs-boot view
@@ -0,0 +1,35 @@+module GI.Gtk.Objects.ComboBox where++import Prelude ()+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 ComboBox = ComboBox (ForeignPtr ComboBox)+instance GObject ComboBox where+class GObject o => ComboBoxK o+instance (GObject o, IsDescendantOf ComboBox o) => ComboBoxK o+data ComboBoxActivePropertyInfo+data ComboBoxActiveIdPropertyInfo+data ComboBoxAddTearoffsPropertyInfo+data ComboBoxButtonSensitivityPropertyInfo+data ComboBoxCellAreaPropertyInfo+data ComboBoxColumnSpanColumnPropertyInfo+data ComboBoxEntryTextColumnPropertyInfo+data ComboBoxFocusOnClickPropertyInfo+data ComboBoxHasEntryPropertyInfo+data ComboBoxHasFramePropertyInfo+data ComboBoxIdColumnPropertyInfo+data ComboBoxModelPropertyInfo+data ComboBoxPopupFixedWidthPropertyInfo+data ComboBoxPopupShownPropertyInfo+data ComboBoxRowSpanColumnPropertyInfo+data ComboBoxTearoffTitlePropertyInfo+data ComboBoxWrapWidthPropertyInfo+data ComboBoxChangedSignalInfo+data ComboBoxFormatEntryTextSignalInfo+data ComboBoxMoveActiveSignalInfo+data ComboBoxPopdownSignalInfo+data ComboBoxPopupSignalInfo
+ GI/Gtk/Objects/ComboBoxAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ComboBoxAccessible+    ( ++-- * Exported types+    ComboBoxAccessible(..)                  ,+    ComboBoxAccessibleK                     ,+    toComboBoxAccessible                    ,+    noComboBoxAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ComboBoxAccessible = ComboBoxAccessible (ForeignPtr ComboBoxAccessible)+foreign import ccall "gtk_combo_box_accessible_get_type"+    c_gtk_combo_box_accessible_get_type :: IO GType++type instance ParentTypes ComboBoxAccessible = ComboBoxAccessibleParentTypes+type ComboBoxAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Selection]++instance GObject ComboBoxAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_combo_box_accessible_get_type+    ++class GObject o => ComboBoxAccessibleK o+instance (GObject o, IsDescendantOf ComboBoxAccessible o) => ComboBoxAccessibleK o++toComboBoxAccessible :: ComboBoxAccessibleK o => o -> IO ComboBoxAccessible+toComboBoxAccessible = unsafeCastTo ComboBoxAccessible++noComboBoxAccessible :: Maybe ComboBoxAccessible+noComboBoxAccessible = Nothing++type instance AttributeList ComboBoxAccessible = ComboBoxAccessibleAttributeList+type ComboBoxAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ComboBoxAccessible = ComboBoxAccessibleSignalList+type ComboBoxAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ComboBoxAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ComboBoxAccessible where++import Prelude ()+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 ComboBoxAccessible = ComboBoxAccessible (ForeignPtr ComboBoxAccessible)+instance GObject ComboBoxAccessible where+class GObject o => ComboBoxAccessibleK o+instance (GObject o, IsDescendantOf ComboBoxAccessible o) => ComboBoxAccessibleK o
+ GI/Gtk/Objects/ComboBoxText.hs view
@@ -0,0 +1,423 @@++{- |+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.Gtk.Objects.ComboBoxText+    ( ++-- * Exported types+    ComboBoxText(..)                        ,+    ComboBoxTextK                           ,+    toComboBoxText                          ,+    noComboBoxText                          ,+++ -- * Methods+-- ** comboBoxTextAppend+    comboBoxTextAppend                      ,+++-- ** comboBoxTextAppendText+    comboBoxTextAppendText                  ,+++-- ** comboBoxTextGetActiveText+    comboBoxTextGetActiveText               ,+++-- ** comboBoxTextInsert+    comboBoxTextInsert                      ,+++-- ** comboBoxTextInsertText+    comboBoxTextInsertText                  ,+++-- ** comboBoxTextNew+    comboBoxTextNew                         ,+++-- ** comboBoxTextNewWithEntry+    comboBoxTextNewWithEntry                ,+++-- ** comboBoxTextPrepend+    comboBoxTextPrepend                     ,+++-- ** comboBoxTextPrependText+    comboBoxTextPrependText                 ,+++-- ** comboBoxTextRemove+    comboBoxTextRemove                      ,+++-- ** comboBoxTextRemoveAll+    comboBoxTextRemoveAll                   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ComboBoxText = ComboBoxText (ForeignPtr ComboBoxText)+foreign import ccall "gtk_combo_box_text_get_type"+    c_gtk_combo_box_text_get_type :: IO GType++type instance ParentTypes ComboBoxText = ComboBoxTextParentTypes+type ComboBoxTextParentTypes = '[ComboBox, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, CellEditable, CellLayout]++instance GObject ComboBoxText where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_combo_box_text_get_type+    ++class GObject o => ComboBoxTextK o+instance (GObject o, IsDescendantOf ComboBoxText o) => ComboBoxTextK o++toComboBoxText :: ComboBoxTextK o => o -> IO ComboBoxText+toComboBoxText = unsafeCastTo ComboBoxText++noComboBoxText :: Maybe ComboBoxText+noComboBoxText = Nothing++type instance AttributeList ComboBoxText = ComboBoxTextAttributeList+type ComboBoxTextAttributeList = ('[ '("active", ComboBoxActivePropertyInfo), '("active-id", ComboBoxActiveIdPropertyInfo), '("add-tearoffs", ComboBoxAddTearoffsPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("button-sensitivity", ComboBoxButtonSensitivityPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cell-area", ComboBoxCellAreaPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-span-column", ComboBoxColumnSpanColumnPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("editing-canceled", CellEditableEditingCanceledPropertyInfo), '("entry-text-column", ComboBoxEntryTextColumnPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ComboBoxFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-entry", ComboBoxHasEntryPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-frame", ComboBoxHasFramePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("id-column", ComboBoxIdColumnPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("model", ComboBoxModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("popup-fixed-width", ComboBoxPopupFixedWidthPropertyInfo), '("popup-shown", ComboBoxPopupShownPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-span-column", ComboBoxRowSpanColumnPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tearoff-title", ComboBoxTearoffTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("wrap-width", ComboBoxWrapWidthPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ComboBoxText = ComboBoxTextSignalList+type ComboBoxTextSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("changed", ComboBoxChangedSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("editing-done", CellEditableEditingDoneSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("format-entry-text", ComboBoxFormatEntryTextSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-active", ComboBoxMoveActiveSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popdown", ComboBoxPopdownSignalInfo), '("popup", ComboBoxPopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("remove-widget", CellEditableRemoveWidgetSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ComboBoxText::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ComboBoxText"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_text_new" gtk_combo_box_text_new :: +    IO (Ptr ComboBoxText)+++comboBoxTextNew ::+    (MonadIO m) =>+    m ComboBoxText+comboBoxTextNew  = liftIO $ do+    result <- gtk_combo_box_text_new+    checkUnexpectedReturnNULL "gtk_combo_box_text_new" result+    result' <- (newObject ComboBoxText) result+    return result'++-- method ComboBoxText::new_with_entry+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ComboBoxText"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_text_new_with_entry" gtk_combo_box_text_new_with_entry :: +    IO (Ptr ComboBoxText)+++comboBoxTextNewWithEntry ::+    (MonadIO m) =>+    m ComboBoxText+comboBoxTextNewWithEntry  = liftIO $ do+    result <- gtk_combo_box_text_new_with_entry+    checkUnexpectedReturnNULL "gtk_combo_box_text_new_with_entry" result+    result' <- (newObject ComboBoxText) result+    return result'++-- method ComboBoxText::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", 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 "gtk_combo_box_text_append" gtk_combo_box_text_append :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    CString ->                              -- id : TBasicType TUTF8+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextAppend ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- id+    T.Text ->                               -- text+    m ()+comboBoxTextAppend _obj id text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeId <- case id of+        Nothing -> return nullPtr+        Just jId -> do+            jId' <- textToCString jId+            return jId'+    text' <- textToCString text+    gtk_combo_box_text_append _obj' maybeId text'+    touchManagedPtr _obj+    freeMem maybeId+    freeMem text'+    return ()++-- method ComboBoxText::append_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_combo_box_text_append_text" gtk_combo_box_text_append_text :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextAppendText ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+comboBoxTextAppendText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_combo_box_text_append_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method ComboBoxText::get_active_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_text_get_active_text" gtk_combo_box_text_get_active_text :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    IO CString+++comboBoxTextGetActiveText ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    m T.Text+comboBoxTextGetActiveText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_combo_box_text_get_active_text _obj'+    checkUnexpectedReturnNULL "gtk_combo_box_text_get_active_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method ComboBoxText::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_combo_box_text_insert" gtk_combo_box_text_insert :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    Int32 ->                                -- position : TBasicType TInt32+    CString ->                              -- id : TBasicType TUTF8+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextInsert ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    Maybe (T.Text) ->                       -- id+    T.Text ->                               -- text+    m ()+comboBoxTextInsert _obj position id text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeId <- case id of+        Nothing -> return nullPtr+        Just jId -> do+            jId' <- textToCString jId+            return jId'+    text' <- textToCString text+    gtk_combo_box_text_insert _obj' position maybeId text'+    touchManagedPtr _obj+    freeMem maybeId+    freeMem text'+    return ()++-- method ComboBoxText::insert_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", 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 "gtk_combo_box_text_insert_text" gtk_combo_box_text_insert_text :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    Int32 ->                                -- position : TBasicType TInt32+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextInsertText ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    T.Text ->                               -- text+    m ()+comboBoxTextInsertText _obj position text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_combo_box_text_insert_text _obj' position text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method ComboBoxText::prepend+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 = "text", 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 "gtk_combo_box_text_prepend" gtk_combo_box_text_prepend :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    CString ->                              -- id : TBasicType TUTF8+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextPrepend ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- id+    T.Text ->                               -- text+    m ()+comboBoxTextPrepend _obj id text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeId <- case id of+        Nothing -> return nullPtr+        Just jId -> do+            jId' <- textToCString jId+            return jId'+    text' <- textToCString text+    gtk_combo_box_text_prepend _obj' maybeId text'+    touchManagedPtr _obj+    freeMem maybeId+    freeMem text'+    return ()++-- method ComboBoxText::prepend_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_combo_box_text_prepend_text" gtk_combo_box_text_prepend_text :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++comboBoxTextPrependText ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+comboBoxTextPrependText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_combo_box_text_prepend_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method ComboBoxText::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", 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 "Gtk" "ComboBoxText", 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 "gtk_combo_box_text_remove" gtk_combo_box_text_remove :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++comboBoxTextRemove ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+comboBoxTextRemove _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_text_remove _obj' position+    touchManagedPtr _obj+    return ()++-- method ComboBoxText::remove_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ComboBoxText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_combo_box_text_remove_all" gtk_combo_box_text_remove_all :: +    Ptr ComboBoxText ->                     -- _obj : TInterface "Gtk" "ComboBoxText"+    IO ()+++comboBoxTextRemoveAll ::+    (MonadIO m, ComboBoxTextK a) =>+    a ->                                    -- _obj+    m ()+comboBoxTextRemoveAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_combo_box_text_remove_all _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ComboBoxText.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ComboBoxText where++import Prelude ()+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 ComboBoxText = ComboBoxText (ForeignPtr ComboBoxText)+instance GObject ComboBoxText where+class GObject o => ComboBoxTextK o+instance (GObject o, IsDescendantOf ComboBoxText o) => ComboBoxTextK o
+ GI/Gtk/Objects/Container.hs view
@@ -0,0 +1,1297 @@++{- |+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.Gtk.Objects.Container+    ( ++-- * Exported types+    Container(..)                           ,+    ContainerK                              ,+    toContainer                             ,+    noContainer                             ,+++ -- * Methods+-- ** containerAdd+    containerAdd                            ,+++-- ** containerCheckResize+    containerCheckResize                    ,+++-- ** containerChildGetProperty+    containerChildGetProperty               ,+++-- ** containerChildNotify+    containerChildNotify                    ,+++-- ** containerChildNotifyByPspec+    containerChildNotifyByPspec             ,+++-- ** containerChildSetProperty+    containerChildSetProperty               ,+++-- ** containerChildType+    containerChildType                      ,+++-- ** containerForall+    containerForall                         ,+++-- ** containerForeach+    containerForeach                        ,+++-- ** containerGetBorderWidth+    containerGetBorderWidth                 ,+++-- ** containerGetChildren+    containerGetChildren                    ,+++-- ** containerGetFocusChain+    containerGetFocusChain                  ,+++-- ** containerGetFocusChild+    containerGetFocusChild                  ,+++-- ** containerGetFocusHadjustment+    containerGetFocusHadjustment            ,+++-- ** containerGetFocusVadjustment+    containerGetFocusVadjustment            ,+++-- ** containerGetPathForChild+    containerGetPathForChild                ,+++-- ** containerGetResizeMode+    containerGetResizeMode                  ,+++-- ** containerPropagateDraw+    containerPropagateDraw                  ,+++-- ** containerRemove+    containerRemove                         ,+++-- ** containerResizeChildren+    containerResizeChildren                 ,+++-- ** containerSetBorderWidth+    containerSetBorderWidth                 ,+++-- ** containerSetFocusChain+    containerSetFocusChain                  ,+++-- ** containerSetFocusChild+    containerSetFocusChild                  ,+++-- ** containerSetFocusHadjustment+    containerSetFocusHadjustment            ,+++-- ** containerSetFocusVadjustment+    containerSetFocusVadjustment            ,+++-- ** containerSetReallocateRedraws+    containerSetReallocateRedraws           ,+++-- ** containerSetResizeMode+    containerSetResizeMode                  ,+++-- ** containerUnsetFocusChain+    containerUnsetFocusChain                ,+++++ -- * Properties+-- ** BorderWidth+    ContainerBorderWidthPropertyInfo        ,+    constructContainerBorderWidth           ,+    getContainerBorderWidth                 ,+    setContainerBorderWidth                 ,+++-- ** Child+    ContainerChildPropertyInfo              ,+    constructContainerChild                 ,+    setContainerChild                       ,+++-- ** ResizeMode+    ContainerResizeModePropertyInfo         ,+    constructContainerResizeMode            ,+    getContainerResizeMode                  ,+    setContainerResizeMode                  ,+++++ -- * Signals+-- ** Add+    ContainerAddCallback                    ,+    ContainerAddCallbackC                   ,+    ContainerAddSignalInfo                  ,+    afterContainerAdd                       ,+    containerAddCallbackWrapper             ,+    containerAddClosure                     ,+    mkContainerAddCallback                  ,+    noContainerAddCallback                  ,+    onContainerAdd                          ,+++-- ** CheckResize+    ContainerCheckResizeCallback            ,+    ContainerCheckResizeCallbackC           ,+    ContainerCheckResizeSignalInfo          ,+    afterContainerCheckResize               ,+    containerCheckResizeCallbackWrapper     ,+    containerCheckResizeClosure             ,+    mkContainerCheckResizeCallback          ,+    noContainerCheckResizeCallback          ,+    onContainerCheckResize                  ,+++-- ** Remove+    ContainerRemoveCallback                 ,+    ContainerRemoveCallbackC                ,+    ContainerRemoveSignalInfo               ,+    afterContainerRemove                    ,+    containerRemoveCallbackWrapper          ,+    containerRemoveClosure                  ,+    mkContainerRemoveCallback               ,+    noContainerRemoveCallback               ,+    onContainerRemove                       ,+++-- ** SetFocusChild+    ContainerSetFocusChildCallback          ,+    ContainerSetFocusChildCallbackC         ,+    ContainerSetFocusChildSignalInfo        ,+    afterContainerSetFocusChild             ,+    containerSetFocusChildCallbackWrapper   ,+    containerSetFocusChildClosure           ,+    mkContainerSetFocusChildCallback        ,+    noContainerSetFocusChildCallback        ,+    onContainerSetFocusChild                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Cairo as Cairo++newtype Container = Container (ForeignPtr Container)+foreign import ccall "gtk_container_get_type"+    c_gtk_container_get_type :: IO GType++type instance ParentTypes Container = ContainerParentTypes+type ContainerParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Container where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_container_get_type+    ++class GObject o => ContainerK o+instance (GObject o, IsDescendantOf Container o) => ContainerK o++toContainer :: ContainerK o => o -> IO Container+toContainer = unsafeCastTo Container++noContainer :: Maybe Container+noContainer = Nothing++-- signal Container::add+type ContainerAddCallback =+    Widget ->+    IO ()++noContainerAddCallback :: Maybe ContainerAddCallback+noContainerAddCallback = Nothing++type ContainerAddCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkContainerAddCallback :: ContainerAddCallbackC -> IO (FunPtr ContainerAddCallbackC)++containerAddClosure :: ContainerAddCallback -> IO Closure+containerAddClosure cb = newCClosure =<< mkContainerAddCallback wrapped+    where wrapped = containerAddCallbackWrapper cb++containerAddCallbackWrapper ::+    ContainerAddCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+containerAddCallbackWrapper _cb _ object _ = do+    object' <- (newObject Widget) object+    _cb  object'++onContainerAdd :: (GObject a, MonadIO m) => a -> ContainerAddCallback -> m SignalHandlerId+onContainerAdd obj cb = liftIO $ connectContainerAdd obj cb SignalConnectBefore+afterContainerAdd :: (GObject a, MonadIO m) => a -> ContainerAddCallback -> m SignalHandlerId+afterContainerAdd obj cb = connectContainerAdd obj cb SignalConnectAfter++connectContainerAdd :: (GObject a, MonadIO m) =>+                       a -> ContainerAddCallback -> SignalConnectMode -> m SignalHandlerId+connectContainerAdd obj cb after = liftIO $ do+    cb' <- mkContainerAddCallback (containerAddCallbackWrapper cb)+    connectSignalFunPtr obj "add" cb' after++-- signal Container::check-resize+type ContainerCheckResizeCallback =+    IO ()++noContainerCheckResizeCallback :: Maybe ContainerCheckResizeCallback+noContainerCheckResizeCallback = Nothing++type ContainerCheckResizeCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkContainerCheckResizeCallback :: ContainerCheckResizeCallbackC -> IO (FunPtr ContainerCheckResizeCallbackC)++containerCheckResizeClosure :: ContainerCheckResizeCallback -> IO Closure+containerCheckResizeClosure cb = newCClosure =<< mkContainerCheckResizeCallback wrapped+    where wrapped = containerCheckResizeCallbackWrapper cb++containerCheckResizeCallbackWrapper ::+    ContainerCheckResizeCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+containerCheckResizeCallbackWrapper _cb _ _ = do+    _cb ++onContainerCheckResize :: (GObject a, MonadIO m) => a -> ContainerCheckResizeCallback -> m SignalHandlerId+onContainerCheckResize obj cb = liftIO $ connectContainerCheckResize obj cb SignalConnectBefore+afterContainerCheckResize :: (GObject a, MonadIO m) => a -> ContainerCheckResizeCallback -> m SignalHandlerId+afterContainerCheckResize obj cb = connectContainerCheckResize obj cb SignalConnectAfter++connectContainerCheckResize :: (GObject a, MonadIO m) =>+                               a -> ContainerCheckResizeCallback -> SignalConnectMode -> m SignalHandlerId+connectContainerCheckResize obj cb after = liftIO $ do+    cb' <- mkContainerCheckResizeCallback (containerCheckResizeCallbackWrapper cb)+    connectSignalFunPtr obj "check-resize" cb' after++-- signal Container::remove+type ContainerRemoveCallback =+    Widget ->+    IO ()++noContainerRemoveCallback :: Maybe ContainerRemoveCallback+noContainerRemoveCallback = Nothing++type ContainerRemoveCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkContainerRemoveCallback :: ContainerRemoveCallbackC -> IO (FunPtr ContainerRemoveCallbackC)++containerRemoveClosure :: ContainerRemoveCallback -> IO Closure+containerRemoveClosure cb = newCClosure =<< mkContainerRemoveCallback wrapped+    where wrapped = containerRemoveCallbackWrapper cb++containerRemoveCallbackWrapper ::+    ContainerRemoveCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+containerRemoveCallbackWrapper _cb _ object _ = do+    object' <- (newObject Widget) object+    _cb  object'++onContainerRemove :: (GObject a, MonadIO m) => a -> ContainerRemoveCallback -> m SignalHandlerId+onContainerRemove obj cb = liftIO $ connectContainerRemove obj cb SignalConnectBefore+afterContainerRemove :: (GObject a, MonadIO m) => a -> ContainerRemoveCallback -> m SignalHandlerId+afterContainerRemove obj cb = connectContainerRemove obj cb SignalConnectAfter++connectContainerRemove :: (GObject a, MonadIO m) =>+                          a -> ContainerRemoveCallback -> SignalConnectMode -> m SignalHandlerId+connectContainerRemove obj cb after = liftIO $ do+    cb' <- mkContainerRemoveCallback (containerRemoveCallbackWrapper cb)+    connectSignalFunPtr obj "remove" cb' after++-- signal Container::set-focus-child+type ContainerSetFocusChildCallback =+    Widget ->+    IO ()++noContainerSetFocusChildCallback :: Maybe ContainerSetFocusChildCallback+noContainerSetFocusChildCallback = Nothing++type ContainerSetFocusChildCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkContainerSetFocusChildCallback :: ContainerSetFocusChildCallbackC -> IO (FunPtr ContainerSetFocusChildCallbackC)++containerSetFocusChildClosure :: ContainerSetFocusChildCallback -> IO Closure+containerSetFocusChildClosure cb = newCClosure =<< mkContainerSetFocusChildCallback wrapped+    where wrapped = containerSetFocusChildCallbackWrapper cb++containerSetFocusChildCallbackWrapper ::+    ContainerSetFocusChildCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+containerSetFocusChildCallbackWrapper _cb _ object _ = do+    object' <- (newObject Widget) object+    _cb  object'++onContainerSetFocusChild :: (GObject a, MonadIO m) => a -> ContainerSetFocusChildCallback -> m SignalHandlerId+onContainerSetFocusChild obj cb = liftIO $ connectContainerSetFocusChild obj cb SignalConnectBefore+afterContainerSetFocusChild :: (GObject a, MonadIO m) => a -> ContainerSetFocusChildCallback -> m SignalHandlerId+afterContainerSetFocusChild obj cb = connectContainerSetFocusChild obj cb SignalConnectAfter++connectContainerSetFocusChild :: (GObject a, MonadIO m) =>+                                 a -> ContainerSetFocusChildCallback -> SignalConnectMode -> m SignalHandlerId+connectContainerSetFocusChild obj cb after = liftIO $ do+    cb' <- mkContainerSetFocusChildCallback (containerSetFocusChildCallbackWrapper cb)+    connectSignalFunPtr obj "set-focus-child" cb' after++-- VVV Prop "border-width"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getContainerBorderWidth :: (MonadIO m, ContainerK o) => o -> m Word32+getContainerBorderWidth obj = liftIO $ getObjectPropertyCUInt obj "border-width"++setContainerBorderWidth :: (MonadIO m, ContainerK o) => o -> Word32 -> m ()+setContainerBorderWidth obj val = liftIO $ setObjectPropertyCUInt obj "border-width" val++constructContainerBorderWidth :: Word32 -> IO ([Char], GValue)+constructContainerBorderWidth val = constructObjectPropertyCUInt "border-width" val++data ContainerBorderWidthPropertyInfo+instance AttrInfo ContainerBorderWidthPropertyInfo where+    type AttrAllowedOps ContainerBorderWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ContainerBorderWidthPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint ContainerBorderWidthPropertyInfo = ContainerK+    type AttrGetType ContainerBorderWidthPropertyInfo = Word32+    type AttrLabel ContainerBorderWidthPropertyInfo = "Container::border-width"+    attrGet _ = getContainerBorderWidth+    attrSet _ = setContainerBorderWidth+    attrConstruct _ = constructContainerBorderWidth++-- VVV Prop "child"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyWritable]++setContainerChild :: (MonadIO m, ContainerK o, WidgetK a) => o -> a -> m ()+setContainerChild obj val = liftIO $ setObjectPropertyObject obj "child" val++constructContainerChild :: (WidgetK a) => a -> IO ([Char], GValue)+constructContainerChild val = constructObjectPropertyObject "child" val++data ContainerChildPropertyInfo+instance AttrInfo ContainerChildPropertyInfo where+    type AttrAllowedOps ContainerChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint ContainerChildPropertyInfo = WidgetK+    type AttrBaseTypeConstraint ContainerChildPropertyInfo = ContainerK+    type AttrGetType ContainerChildPropertyInfo = ()+    type AttrLabel ContainerChildPropertyInfo = "Container::child"+    attrGet _ = undefined+    attrSet _ = setContainerChild+    attrConstruct _ = constructContainerChild++-- VVV Prop "resize-mode"+   -- Type: TInterface "Gtk" "ResizeMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getContainerResizeMode :: (MonadIO m, ContainerK o) => o -> m ResizeMode+getContainerResizeMode obj = liftIO $ getObjectPropertyEnum obj "resize-mode"++setContainerResizeMode :: (MonadIO m, ContainerK o) => o -> ResizeMode -> m ()+setContainerResizeMode obj val = liftIO $ setObjectPropertyEnum obj "resize-mode" val++constructContainerResizeMode :: ResizeMode -> IO ([Char], GValue)+constructContainerResizeMode val = constructObjectPropertyEnum "resize-mode" val++data ContainerResizeModePropertyInfo+instance AttrInfo ContainerResizeModePropertyInfo where+    type AttrAllowedOps ContainerResizeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ContainerResizeModePropertyInfo = (~) ResizeMode+    type AttrBaseTypeConstraint ContainerResizeModePropertyInfo = ContainerK+    type AttrGetType ContainerResizeModePropertyInfo = ResizeMode+    type AttrLabel ContainerResizeModePropertyInfo = "Container::resize-mode"+    attrGet _ = getContainerResizeMode+    attrSet _ = setContainerResizeMode+    attrConstruct _ = constructContainerResizeMode++type instance AttributeList Container = ContainerAttributeList+type ContainerAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data ContainerAddSignalInfo+instance SignalInfo ContainerAddSignalInfo where+    type HaskellCallbackType ContainerAddSignalInfo = ContainerAddCallback+    connectSignal _ = connectContainerAdd++data ContainerCheckResizeSignalInfo+instance SignalInfo ContainerCheckResizeSignalInfo where+    type HaskellCallbackType ContainerCheckResizeSignalInfo = ContainerCheckResizeCallback+    connectSignal _ = connectContainerCheckResize++data ContainerRemoveSignalInfo+instance SignalInfo ContainerRemoveSignalInfo where+    type HaskellCallbackType ContainerRemoveSignalInfo = ContainerRemoveCallback+    connectSignal _ = connectContainerRemove++data ContainerSetFocusChildSignalInfo+instance SignalInfo ContainerSetFocusChildSignalInfo where+    type HaskellCallbackType ContainerSetFocusChildSignalInfo = ContainerSetFocusChildCallback+    connectSignal _ = connectContainerSetFocusChild++type instance SignalList Container = ContainerSignalList+type ContainerSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Container::add+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_add" gtk_container_add :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++containerAdd ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m ()+containerAdd _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_container_add _obj' widget'+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method Container::check_resize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_check_resize" gtk_container_check_resize :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO ()+++containerCheckResize ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m ()+containerCheckResize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_container_check_resize _obj'+    touchManagedPtr _obj+    return ()++-- method Container::child_get_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_child_get_property" gtk_container_child_get_property :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CString ->                              -- property_name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++containerChildGetProperty ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    T.Text ->                               -- property_name+    GValue ->                               -- value+    m ()+containerChildGetProperty _obj child property_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    property_name' <- textToCString property_name+    let value' = unsafeManagedPtrGetPtr value+    gtk_container_child_get_property _obj' child' property_name' value'+    touchManagedPtr _obj+    touchManagedPtr child+    touchManagedPtr value+    freeMem property_name'+    return ()++-- method Container::child_notify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_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 "gtk_container_child_notify" gtk_container_child_notify :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CString ->                              -- child_property : TBasicType TUTF8+    IO ()+++containerChildNotify ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    T.Text ->                               -- child_property+    m ()+containerChildNotify _obj child child_property = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    child_property' <- textToCString child_property+    gtk_container_child_notify _obj' child' child_property'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem child_property'+    return ()++-- method Container::child_notify_by_pspec+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_child_notify_by_pspec" gtk_container_child_notify_by_pspec :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr GParamSpec ->                       -- pspec : TParamSpec+    IO ()+++containerChildNotifyByPspec ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    GParamSpec ->                           -- pspec+    m ()+containerChildNotifyByPspec _obj child pspec = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let pspec' = unsafeManagedPtrGetPtr pspec+    gtk_container_child_notify_by_pspec _obj' child' pspec'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Container::child_set_property+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_child_set_property" gtk_container_child_set_property :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CString ->                              -- property_name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++containerChildSetProperty ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    T.Text ->                               -- property_name+    GValue ->                               -- value+    m ()+containerChildSetProperty _obj child property_name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    property_name' <- textToCString property_name+    let value' = unsafeManagedPtrGetPtr value+    gtk_container_child_set_property _obj' child' property_name' value'+    touchManagedPtr _obj+    touchManagedPtr child+    touchManagedPtr value+    freeMem property_name'+    return ()++-- method Container::child_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_child_type" gtk_container_child_type :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO CGType+++containerChildType ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m GType+containerChildType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_child_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++-- method Container::forall+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_forall" gtk_container_forall :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    FunPtr CallbackC ->                     -- callback : TInterface "Gtk" "Callback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    IO ()+++containerForall ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    Callback ->                             -- callback+    m ()+containerForall _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    callback' <- mkCallback (callbackWrapper Nothing callback)+    let callback_data = nullPtr+    gtk_container_forall _obj' callback' callback_data+    safeFreeFunPtr $ castFunPtrToPtr callback'+    touchManagedPtr _obj+    return ()++-- method Container::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Gtk" "Callback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_foreach" gtk_container_foreach :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    FunPtr CallbackC ->                     -- callback : TInterface "Gtk" "Callback"+    Ptr () ->                               -- callback_data : TBasicType TVoid+    IO ()+++containerForeach ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    Callback ->                             -- callback+    m ()+containerForeach _obj callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    callback' <- mkCallback (callbackWrapper Nothing callback)+    let callback_data = nullPtr+    gtk_container_foreach _obj' callback' callback_data+    safeFreeFunPtr $ castFunPtrToPtr callback'+    touchManagedPtr _obj+    return ()++-- method Container::get_border_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_border_width" gtk_container_get_border_width :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO Word32+++containerGetBorderWidth ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m Word32+containerGetBorderWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_border_width _obj'+    touchManagedPtr _obj+    return result++-- method Container::get_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "Widget")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_children" gtk_container_get_children :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO (Ptr (GList (Ptr Widget)))+++containerGetChildren ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m [Widget]+containerGetChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_children _obj'+    checkUnexpectedReturnNULL "gtk_container_get_children" result+    result' <- unpackGList result+    result'' <- mapM (newObject Widget) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Container::get_focus_chain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focusable_widgets", argType = TGList (TInterface "Gtk" "Widget"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferContainer}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_focus_chain" gtk_container_get_focus_chain :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr (Ptr (GList (Ptr Widget))) ->       -- focusable_widgets : TGList (TInterface "Gtk" "Widget")+    IO CInt+++containerGetFocusChain ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m (Bool,[Widget])+containerGetFocusChain _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    focusable_widgets <- allocMem :: IO (Ptr (Ptr (GList (Ptr Widget))))+    result <- gtk_container_get_focus_chain _obj' focusable_widgets+    let result' = (/= 0) result+    focusable_widgets' <- peek focusable_widgets+    focusable_widgets'' <- unpackGList focusable_widgets'+    focusable_widgets''' <- mapM (newObject Widget) focusable_widgets''+    g_list_free focusable_widgets'+    touchManagedPtr _obj+    freeMem focusable_widgets+    return (result', focusable_widgets''')++-- method Container::get_focus_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_focus_child" gtk_container_get_focus_child :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO (Ptr Widget)+++containerGetFocusChild ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m Widget+containerGetFocusChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_focus_child _obj'+    checkUnexpectedReturnNULL "gtk_container_get_focus_child" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Container::get_focus_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_focus_hadjustment" gtk_container_get_focus_hadjustment :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO (Ptr Adjustment)+++containerGetFocusHadjustment ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m Adjustment+containerGetFocusHadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_focus_hadjustment _obj'+    checkUnexpectedReturnNULL "gtk_container_get_focus_hadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Container::get_focus_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_focus_vadjustment" gtk_container_get_focus_vadjustment :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO (Ptr Adjustment)+++containerGetFocusVadjustment ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m Adjustment+containerGetFocusVadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_focus_vadjustment _obj'+    checkUnexpectedReturnNULL "gtk_container_get_focus_vadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Container::get_path_for_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "WidgetPath"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_path_for_child" gtk_container_get_path_for_child :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO (Ptr WidgetPath)+++containerGetPathForChild ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m WidgetPath+containerGetPathForChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_container_get_path_for_child _obj' child'+    checkUnexpectedReturnNULL "gtk_container_get_path_for_child" result+    result' <- (wrapBoxed WidgetPath) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Container::get_resize_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ResizeMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_get_resize_mode" gtk_container_get_resize_mode :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO CUInt++{-# DEPRECATED containerGetResizeMode ["(Since version 3.12)","Resize modes are deprecated. They aren\8217t necessary","    anymore since frame clocks and might introduce obscure bugs if","    used."]#-}+containerGetResizeMode ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m ResizeMode+containerGetResizeMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_get_resize_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Container::propagate_draw+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_propagate_draw" gtk_container_propagate_draw :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    IO ()+++containerPropagateDraw ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Cairo.Context ->                        -- cr+    m ()+containerPropagateDraw _obj child cr = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let cr' = unsafeManagedPtrGetPtr cr+    gtk_container_propagate_draw _obj' child' cr'+    touchManagedPtr _obj+    touchManagedPtr child+    touchManagedPtr cr+    return ()++-- method Container::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_remove" gtk_container_remove :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++containerRemove ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m ()+containerRemove _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_container_remove _obj' widget'+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method Container::resize_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_resize_children" gtk_container_resize_children :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO ()++{-# DEPRECATED containerResizeChildren ["(Since version 3.10)"]#-}+containerResizeChildren ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m ()+containerResizeChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_container_resize_children _obj'+    touchManagedPtr _obj+    return ()++-- method Container::set_border_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border_width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border_width", 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 "gtk_container_set_border_width" gtk_container_set_border_width :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Word32 ->                               -- border_width : TBasicType TUInt32+    IO ()+++containerSetBorderWidth ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- border_width+    m ()+containerSetBorderWidth _obj border_width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_container_set_border_width _obj' border_width+    touchManagedPtr _obj+    return ()++-- method Container::set_focus_chain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focusable_widgets", argType = TGList (TInterface "Gtk" "Widget"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focusable_widgets", argType = TGList (TInterface "Gtk" "Widget"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_set_focus_chain" gtk_container_set_focus_chain :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr (GList (Ptr Widget)) ->             -- focusable_widgets : TGList (TInterface "Gtk" "Widget")+    IO ()+++containerSetFocusChain ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    [b] ->                                  -- focusable_widgets+    m ()+containerSetFocusChain _obj focusable_widgets = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let focusable_widgets' = map unsafeManagedPtrCastPtr focusable_widgets+    focusable_widgets'' <- packGList focusable_widgets'+    gtk_container_set_focus_chain _obj' focusable_widgets''+    touchManagedPtr _obj+    mapM_ touchManagedPtr focusable_widgets+    g_list_free focusable_widgets''+    return ()++-- method Container::set_focus_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_set_focus_child" gtk_container_set_focus_child :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++containerSetFocusChild ::+    (MonadIO m, ContainerK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- child+    m ()+containerSetFocusChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeChild <- case child of+        Nothing -> return nullPtr+        Just jChild -> do+            let jChild' = unsafeManagedPtrCastPtr jChild+            return jChild'+    gtk_container_set_focus_child _obj' maybeChild+    touchManagedPtr _obj+    whenJust child touchManagedPtr+    return ()++-- method Container::set_focus_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_set_focus_hadjustment" gtk_container_set_focus_hadjustment :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++containerSetFocusHadjustment ::+    (MonadIO m, ContainerK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+containerSetFocusHadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_container_set_focus_hadjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method Container::set_focus_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_set_focus_vadjustment" gtk_container_set_focus_vadjustment :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++containerSetFocusVadjustment ::+    (MonadIO m, ContainerK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+containerSetFocusVadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_container_set_focus_vadjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method Container::set_reallocate_redraws+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "needs_redraws", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "needs_redraws", 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 "gtk_container_set_reallocate_redraws" gtk_container_set_reallocate_redraws :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    CInt ->                                 -- needs_redraws : TBasicType TBoolean+    IO ()++{-# DEPRECATED containerSetReallocateRedraws ["(Since version 3.14)","Call gtk_widget_queue_draw() in your size_allocate handler."]#-}+containerSetReallocateRedraws ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- needs_redraws+    m ()+containerSetReallocateRedraws _obj needs_redraws = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let needs_redraws' = (fromIntegral . fromEnum) needs_redraws+    gtk_container_set_reallocate_redraws _obj' needs_redraws'+    touchManagedPtr _obj+    return ()++-- method Container::set_resize_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize_mode", argType = TInterface "Gtk" "ResizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize_mode", argType = TInterface "Gtk" "ResizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_set_resize_mode" gtk_container_set_resize_mode :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    CUInt ->                                -- resize_mode : TInterface "Gtk" "ResizeMode"+    IO ()++{-# DEPRECATED containerSetResizeMode ["(Since version 3.12)","Resize modes are deprecated. They aren\8217t necessary","    anymore since frame clocks and might introduce obscure bugs if","    used."]#-}+containerSetResizeMode ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    ResizeMode ->                           -- resize_mode+    m ()+containerSetResizeMode _obj resize_mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let resize_mode' = (fromIntegral . fromEnum) resize_mode+    gtk_container_set_resize_mode _obj' resize_mode'+    touchManagedPtr _obj+    return ()++-- method Container::unset_focus_chain+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Container", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_unset_focus_chain" gtk_container_unset_focus_chain :: +    Ptr Container ->                        -- _obj : TInterface "Gtk" "Container"+    IO ()+++containerUnsetFocusChain ::+    (MonadIO m, ContainerK a) =>+    a ->                                    -- _obj+    m ()+containerUnsetFocusChain _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_container_unset_focus_chain _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Container.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gtk.Objects.Container where++import Prelude ()+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 Container = Container (ForeignPtr Container)+instance GObject Container where+class GObject o => ContainerK o+instance (GObject o, IsDescendantOf Container o) => ContainerK o+data ContainerBorderWidthPropertyInfo+data ContainerChildPropertyInfo+data ContainerResizeModePropertyInfo+data ContainerAddSignalInfo+data ContainerCheckResizeSignalInfo+data ContainerRemoveSignalInfo+data ContainerSetFocusChildSignalInfo
+ GI/Gtk/Objects/ContainerAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ContainerAccessible+    ( ++-- * Exported types+    ContainerAccessible(..)                 ,+    ContainerAccessibleK                    ,+    toContainerAccessible                   ,+    noContainerAccessible                   ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ContainerAccessible = ContainerAccessible (ForeignPtr ContainerAccessible)+foreign import ccall "gtk_container_accessible_get_type"+    c_gtk_container_accessible_get_type :: IO GType++type instance ParentTypes ContainerAccessible = ContainerAccessibleParentTypes+type ContainerAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component]++instance GObject ContainerAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_container_accessible_get_type+    ++class GObject o => ContainerAccessibleK o+instance (GObject o, IsDescendantOf ContainerAccessible o) => ContainerAccessibleK o++toContainerAccessible :: ContainerAccessibleK o => o -> IO ContainerAccessible+toContainerAccessible = unsafeCastTo ContainerAccessible++noContainerAccessible :: Maybe ContainerAccessible+noContainerAccessible = Nothing++type instance AttributeList ContainerAccessible = ContainerAccessibleAttributeList+type ContainerAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ContainerAccessible = ContainerAccessibleSignalList+type ContainerAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ContainerAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ContainerAccessible where++import Prelude ()+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 ContainerAccessible = ContainerAccessible (ForeignPtr ContainerAccessible)+instance GObject ContainerAccessible where+class GObject o => ContainerAccessibleK o+instance (GObject o, IsDescendantOf ContainerAccessible o) => ContainerAccessibleK o
+ GI/Gtk/Objects/ContainerCellAccessible.hs view
@@ -0,0 +1,183 @@++{- |+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.Gtk.Objects.ContainerCellAccessible+    ( ++-- * Exported types+    ContainerCellAccessible(..)             ,+    ContainerCellAccessibleK                ,+    toContainerCellAccessible               ,+    noContainerCellAccessible               ,+++ -- * Methods+-- ** containerCellAccessibleAddChild+    containerCellAccessibleAddChild         ,+++-- ** containerCellAccessibleGetChildren+    containerCellAccessibleGetChildren      ,+++-- ** containerCellAccessibleNew+    containerCellAccessibleNew              ,+++-- ** containerCellAccessibleRemoveChild+    containerCellAccessibleRemoveChild      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ContainerCellAccessible = ContainerCellAccessible (ForeignPtr ContainerCellAccessible)+foreign import ccall "gtk_container_cell_accessible_get_type"+    c_gtk_container_cell_accessible_get_type :: IO GType++type instance ParentTypes ContainerCellAccessible = ContainerCellAccessibleParentTypes+type ContainerCellAccessibleParentTypes = '[CellAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component]++instance GObject ContainerCellAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_container_cell_accessible_get_type+    ++class GObject o => ContainerCellAccessibleK o+instance (GObject o, IsDescendantOf ContainerCellAccessible o) => ContainerCellAccessibleK o++toContainerCellAccessible :: ContainerCellAccessibleK o => o -> IO ContainerCellAccessible+toContainerCellAccessible = unsafeCastTo ContainerCellAccessible++noContainerCellAccessible :: Maybe ContainerCellAccessible+noContainerCellAccessible = Nothing++type instance AttributeList ContainerCellAccessible = ContainerCellAccessibleAttributeList+type ContainerCellAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ContainerCellAccessible = ContainerCellAccessibleSignalList+type ContainerCellAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ContainerCellAccessible::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ContainerCellAccessible"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_cell_accessible_new" gtk_container_cell_accessible_new :: +    IO (Ptr ContainerCellAccessible)+++containerCellAccessibleNew ::+    (MonadIO m) =>+    m ContainerCellAccessible+containerCellAccessibleNew  = liftIO $ do+    result <- gtk_container_cell_accessible_new+    checkUnexpectedReturnNULL "gtk_container_cell_accessible_new" result+    result' <- (wrapObject ContainerCellAccessible) result+    return result'++-- method ContainerCellAccessible::add_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_cell_accessible_add_child" gtk_container_cell_accessible_add_child :: +    Ptr ContainerCellAccessible ->          -- _obj : TInterface "Gtk" "ContainerCellAccessible"+    Ptr CellAccessible ->                   -- child : TInterface "Gtk" "CellAccessible"+    IO ()+++containerCellAccessibleAddChild ::+    (MonadIO m, ContainerCellAccessibleK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+containerCellAccessibleAddChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_container_cell_accessible_add_child _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ContainerCellAccessible::get_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "CellAccessible")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_cell_accessible_get_children" gtk_container_cell_accessible_get_children :: +    Ptr ContainerCellAccessible ->          -- _obj : TInterface "Gtk" "ContainerCellAccessible"+    IO (Ptr (GList (Ptr CellAccessible)))+++containerCellAccessibleGetChildren ::+    (MonadIO m, ContainerCellAccessibleK a) =>+    a ->                                    -- _obj+    m [CellAccessible]+containerCellAccessibleGetChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_container_cell_accessible_get_children _obj'+    checkUnexpectedReturnNULL "gtk_container_cell_accessible_get_children" result+    result' <- unpackGList result+    result'' <- mapM (newObject CellAccessible) result'+    touchManagedPtr _obj+    return result''++-- method ContainerCellAccessible::remove_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ContainerCellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "CellAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_container_cell_accessible_remove_child" gtk_container_cell_accessible_remove_child :: +    Ptr ContainerCellAccessible ->          -- _obj : TInterface "Gtk" "ContainerCellAccessible"+    Ptr CellAccessible ->                   -- child : TInterface "Gtk" "CellAccessible"+    IO ()+++containerCellAccessibleRemoveChild ::+    (MonadIO m, ContainerCellAccessibleK a, CellAccessibleK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+containerCellAccessibleRemoveChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_container_cell_accessible_remove_child _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++
+ GI/Gtk/Objects/ContainerCellAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ContainerCellAccessible where++import Prelude ()+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 ContainerCellAccessible = ContainerCellAccessible (ForeignPtr ContainerCellAccessible)+instance GObject ContainerCellAccessible where+class GObject o => ContainerCellAccessibleK o+instance (GObject o, IsDescendantOf ContainerCellAccessible o) => ContainerCellAccessibleK o
+ GI/Gtk/Objects/CssProvider.hs view
@@ -0,0 +1,394 @@++{- |+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.Gtk.Objects.CssProvider+    ( ++-- * Exported types+    CssProvider(..)                         ,+    CssProviderK                            ,+    toCssProvider                           ,+    noCssProvider                           ,+++ -- * Methods+-- ** cssProviderGetDefault+    cssProviderGetDefault                   ,+++-- ** cssProviderGetNamed+    cssProviderGetNamed                     ,+++-- ** cssProviderLoadFromData+    cssProviderLoadFromData                 ,+++-- ** cssProviderLoadFromFile+    cssProviderLoadFromFile                 ,+++-- ** cssProviderLoadFromPath+    cssProviderLoadFromPath                 ,+++-- ** cssProviderLoadFromResource+    cssProviderLoadFromResource             ,+++-- ** cssProviderNew+    cssProviderNew                          ,+++-- ** cssProviderToString+    cssProviderToString                     ,+++++ -- * Signals+-- ** ParsingError+    CssProviderParsingErrorCallback         ,+    CssProviderParsingErrorCallbackC        ,+    CssProviderParsingErrorSignalInfo       ,+    afterCssProviderParsingError            ,+    cssProviderParsingErrorCallbackWrapper  ,+    cssProviderParsingErrorClosure          ,+    mkCssProviderParsingErrorCallback       ,+    noCssProviderParsingErrorCallback       ,+    onCssProviderParsingError               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype CssProvider = CssProvider (ForeignPtr CssProvider)+foreign import ccall "gtk_css_provider_get_type"+    c_gtk_css_provider_get_type :: IO GType++type instance ParentTypes CssProvider = CssProviderParentTypes+type CssProviderParentTypes = '[GObject.Object, StyleProvider]++instance GObject CssProvider where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_css_provider_get_type+    ++class GObject o => CssProviderK o+instance (GObject o, IsDescendantOf CssProvider o) => CssProviderK o++toCssProvider :: CssProviderK o => o -> IO CssProvider+toCssProvider = unsafeCastTo CssProvider++noCssProvider :: Maybe CssProvider+noCssProvider = Nothing++-- signal CssProvider::parsing-error+type CssProviderParsingErrorCallback =+    CssSection ->+    GError ->+    IO ()++noCssProviderParsingErrorCallback :: Maybe CssProviderParsingErrorCallback+noCssProviderParsingErrorCallback = Nothing++type CssProviderParsingErrorCallbackC =+    Ptr () ->                               -- object+    Ptr CssSection ->+    Ptr GError ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkCssProviderParsingErrorCallback :: CssProviderParsingErrorCallbackC -> IO (FunPtr CssProviderParsingErrorCallbackC)++cssProviderParsingErrorClosure :: CssProviderParsingErrorCallback -> IO Closure+cssProviderParsingErrorClosure cb = newCClosure =<< mkCssProviderParsingErrorCallback wrapped+    where wrapped = cssProviderParsingErrorCallbackWrapper cb++cssProviderParsingErrorCallbackWrapper ::+    CssProviderParsingErrorCallback ->+    Ptr () ->+    Ptr CssSection ->+    Ptr GError ->+    Ptr () ->+    IO ()+cssProviderParsingErrorCallbackWrapper _cb _ section error_ _ = do+    section' <- (newBoxed CssSection) section+    error_' <- (newBoxed GError) error_+    _cb  section' error_'++onCssProviderParsingError :: (GObject a, MonadIO m) => a -> CssProviderParsingErrorCallback -> m SignalHandlerId+onCssProviderParsingError obj cb = liftIO $ connectCssProviderParsingError obj cb SignalConnectBefore+afterCssProviderParsingError :: (GObject a, MonadIO m) => a -> CssProviderParsingErrorCallback -> m SignalHandlerId+afterCssProviderParsingError obj cb = connectCssProviderParsingError obj cb SignalConnectAfter++connectCssProviderParsingError :: (GObject a, MonadIO m) =>+                                  a -> CssProviderParsingErrorCallback -> SignalConnectMode -> m SignalHandlerId+connectCssProviderParsingError obj cb after = liftIO $ do+    cb' <- mkCssProviderParsingErrorCallback (cssProviderParsingErrorCallbackWrapper cb)+    connectSignalFunPtr obj "parsing-error" cb' after++type instance AttributeList CssProvider = CssProviderAttributeList+type CssProviderAttributeList = ('[ ] :: [(Symbol, *)])++data CssProviderParsingErrorSignalInfo+instance SignalInfo CssProviderParsingErrorSignalInfo where+    type HaskellCallbackType CssProviderParsingErrorSignalInfo = CssProviderParsingErrorCallback+    connectSignal _ = connectCssProviderParsingError++type instance SignalList CssProvider = CssProviderSignalList+type CssProviderSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("parsing-error", CssProviderParsingErrorSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method CssProvider::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CssProvider"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_css_provider_new" gtk_css_provider_new :: +    IO (Ptr CssProvider)+++cssProviderNew ::+    (MonadIO m) =>+    m CssProvider+cssProviderNew  = liftIO $ do+    result <- gtk_css_provider_new+    checkUnexpectedReturnNULL "gtk_css_provider_new" result+    result' <- (wrapObject CssProvider) result+    return result'++-- method CssProvider::load_from_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", 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},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", 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 : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_css_provider_load_from_data" gtk_css_provider_load_from_data :: +    Ptr CssProvider ->                      -- _obj : TInterface "Gtk" "CssProvider"+    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)+    Int64 ->                                -- length : TBasicType TInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++cssProviderLoadFromData ::+    (MonadIO m, CssProviderK a) =>+    a ->                                    -- _obj+    ByteString ->                           -- data+    m ()+cssProviderLoadFromData _obj data_ = liftIO $ do+    let length_ = fromIntegral $ B.length data_+    let _obj' = unsafeManagedPtrCastPtr _obj+    data_' <- packByteString data_+    onException (do+        _ <- propagateGError $ gtk_css_provider_load_from_data _obj' data_' length_+        touchManagedPtr _obj+        freeMem data_'+        return ()+     ) (do+        freeMem data_'+     )++-- method CssProvider::load_from_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_css_provider_load_from_file" gtk_css_provider_load_from_file :: +    Ptr CssProvider ->                      -- _obj : TInterface "Gtk" "CssProvider"+    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++cssProviderLoadFromFile ::+    (MonadIO m, CssProviderK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- file+    m ()+cssProviderLoadFromFile _obj file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let file' = unsafeManagedPtrCastPtr file+    onException (do+        _ <- propagateGError $ gtk_css_provider_load_from_file _obj' file'+        touchManagedPtr _obj+        touchManagedPtr file+        return ()+     ) (do+        return ()+     )++-- method CssProvider::load_from_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", 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 "Gtk" "CssProvider", 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 TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_css_provider_load_from_path" gtk_css_provider_load_from_path :: +    Ptr CssProvider ->                      -- _obj : TInterface "Gtk" "CssProvider"+    CString ->                              -- path : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++cssProviderLoadFromPath ::+    (MonadIO m, CssProviderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+cssProviderLoadFromPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    onException (do+        _ <- propagateGError $ gtk_css_provider_load_from_path _obj' path'+        touchManagedPtr _obj+        freeMem path'+        return ()+     ) (do+        freeMem path'+     )++-- method CssProvider::load_from_resource+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resource_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 "gtk_css_provider_load_from_resource" gtk_css_provider_load_from_resource :: +    Ptr CssProvider ->                      -- _obj : TInterface "Gtk" "CssProvider"+    CString ->                              -- resource_path : TBasicType TUTF8+    IO ()+++cssProviderLoadFromResource ::+    (MonadIO m, CssProviderK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- resource_path+    m ()+cssProviderLoadFromResource _obj resource_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    resource_path' <- textToCString resource_path+    gtk_css_provider_load_from_resource _obj' resource_path'+    touchManagedPtr _obj+    freeMem resource_path'+    return ()++-- method CssProvider::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "CssProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_css_provider_to_string" gtk_css_provider_to_string :: +    Ptr CssProvider ->                      -- _obj : TInterface "Gtk" "CssProvider"+    IO CString+++cssProviderToString ::+    (MonadIO m, CssProviderK a) =>+    a ->                                    -- _obj+    m T.Text+cssProviderToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_css_provider_to_string _obj'+    checkUnexpectedReturnNULL "gtk_css_provider_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method CssProvider::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "CssProvider"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_css_provider_get_default" gtk_css_provider_get_default :: +    IO (Ptr CssProvider)+++cssProviderGetDefault ::+    (MonadIO m) =>+    m CssProvider+cssProviderGetDefault  = liftIO $ do+    result <- gtk_css_provider_get_default+    checkUnexpectedReturnNULL "gtk_css_provider_get_default" result+    result' <- (newObject CssProvider) result+    return result'++-- method CssProvider::get_named+-- method type : MemberFunction+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "variant", argType = TBasicType TUTF8, 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 = "variant", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "CssProvider"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_css_provider_get_named" gtk_css_provider_get_named :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- variant : TBasicType TUTF8+    IO (Ptr CssProvider)+++cssProviderGetNamed ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (T.Text) ->                       -- variant+    m CssProvider+cssProviderGetNamed name variant = liftIO $ do+    name' <- textToCString name+    maybeVariant <- case variant of+        Nothing -> return nullPtr+        Just jVariant -> do+            jVariant' <- textToCString jVariant+            return jVariant'+    result <- gtk_css_provider_get_named name' maybeVariant+    checkUnexpectedReturnNULL "gtk_css_provider_get_named" result+    result' <- (newObject CssProvider) result+    freeMem name'+    freeMem maybeVariant+    return result'++
+ GI/Gtk/Objects/CssProvider.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.CssProvider where++import Prelude ()+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 CssProvider = CssProvider (ForeignPtr CssProvider)+instance GObject CssProvider where+class GObject o => CssProviderK o+instance (GObject o, IsDescendantOf CssProvider o) => CssProviderK o+data CssProviderParsingErrorSignalInfo
+ GI/Gtk/Objects/Dialog.hs view
@@ -0,0 +1,613 @@++{- |+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.Gtk.Objects.Dialog+    ( ++-- * Exported types+    Dialog(..)                              ,+    DialogK                                 ,+    toDialog                                ,+    noDialog                                ,+++ -- * Methods+-- ** dialogAddActionWidget+    dialogAddActionWidget                   ,+++-- ** dialogAddButton+    dialogAddButton                         ,+++-- ** dialogGetActionArea+    dialogGetActionArea                     ,+++-- ** dialogGetContentArea+    dialogGetContentArea                    ,+++-- ** dialogGetHeaderBar+    dialogGetHeaderBar                      ,+++-- ** dialogGetResponseForWidget+    dialogGetResponseForWidget              ,+++-- ** dialogGetWidgetForResponse+    dialogGetWidgetForResponse              ,+++-- ** dialogNew+    dialogNew                               ,+++-- ** dialogResponse+    dialogResponse                          ,+++-- ** dialogRun+    dialogRun                               ,+++-- ** dialogSetAlternativeButtonOrderFromArray+    dialogSetAlternativeButtonOrderFromArray,+++-- ** dialogSetDefaultResponse+    dialogSetDefaultResponse                ,+++-- ** dialogSetResponseSensitive+    dialogSetResponseSensitive              ,+++++ -- * Properties+-- ** UseHeaderBar+    DialogUseHeaderBarPropertyInfo          ,+    constructDialogUseHeaderBar             ,+    getDialogUseHeaderBar                   ,+++++ -- * Signals+-- ** Close+    DialogCloseCallback                     ,+    DialogCloseCallbackC                    ,+    DialogCloseSignalInfo                   ,+    afterDialogClose                        ,+    dialogCloseCallbackWrapper              ,+    dialogCloseClosure                      ,+    mkDialogCloseCallback                   ,+    noDialogCloseCallback                   ,+    onDialogClose                           ,+++-- ** Response+    DialogResponseCallback                  ,+    DialogResponseCallbackC                 ,+    DialogResponseSignalInfo                ,+    afterDialogResponse                     ,+    dialogResponseCallbackWrapper           ,+    dialogResponseClosure                   ,+    mkDialogResponseCallback                ,+    noDialogResponseCallback                ,+    onDialogResponse                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Dialog = Dialog (ForeignPtr Dialog)+foreign import ccall "gtk_dialog_get_type"+    c_gtk_dialog_get_type :: IO GType++type instance ParentTypes Dialog = DialogParentTypes+type DialogParentTypes = '[Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Dialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_dialog_get_type+    ++class GObject o => DialogK o+instance (GObject o, IsDescendantOf Dialog o) => DialogK o++toDialog :: DialogK o => o -> IO Dialog+toDialog = unsafeCastTo Dialog++noDialog :: Maybe Dialog+noDialog = Nothing++-- signal Dialog::close+type DialogCloseCallback =+    IO ()++noDialogCloseCallback :: Maybe DialogCloseCallback+noDialogCloseCallback = Nothing++type DialogCloseCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDialogCloseCallback :: DialogCloseCallbackC -> IO (FunPtr DialogCloseCallbackC)++dialogCloseClosure :: DialogCloseCallback -> IO Closure+dialogCloseClosure cb = newCClosure =<< mkDialogCloseCallback wrapped+    where wrapped = dialogCloseCallbackWrapper cb++dialogCloseCallbackWrapper ::+    DialogCloseCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+dialogCloseCallbackWrapper _cb _ _ = do+    _cb ++onDialogClose :: (GObject a, MonadIO m) => a -> DialogCloseCallback -> m SignalHandlerId+onDialogClose obj cb = liftIO $ connectDialogClose obj cb SignalConnectBefore+afterDialogClose :: (GObject a, MonadIO m) => a -> DialogCloseCallback -> m SignalHandlerId+afterDialogClose obj cb = connectDialogClose obj cb SignalConnectAfter++connectDialogClose :: (GObject a, MonadIO m) =>+                      a -> DialogCloseCallback -> SignalConnectMode -> m SignalHandlerId+connectDialogClose obj cb after = liftIO $ do+    cb' <- mkDialogCloseCallback (dialogCloseCallbackWrapper cb)+    connectSignalFunPtr obj "close" cb' after++-- signal Dialog::response+type DialogResponseCallback =+    Int32 ->+    IO ()++noDialogResponseCallback :: Maybe DialogResponseCallback+noDialogResponseCallback = Nothing++type DialogResponseCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDialogResponseCallback :: DialogResponseCallbackC -> IO (FunPtr DialogResponseCallbackC)++dialogResponseClosure :: DialogResponseCallback -> IO Closure+dialogResponseClosure cb = newCClosure =<< mkDialogResponseCallback wrapped+    where wrapped = dialogResponseCallbackWrapper cb++dialogResponseCallbackWrapper ::+    DialogResponseCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+dialogResponseCallbackWrapper _cb _ response_id _ = do+    _cb  response_id++onDialogResponse :: (GObject a, MonadIO m) => a -> DialogResponseCallback -> m SignalHandlerId+onDialogResponse obj cb = liftIO $ connectDialogResponse obj cb SignalConnectBefore+afterDialogResponse :: (GObject a, MonadIO m) => a -> DialogResponseCallback -> m SignalHandlerId+afterDialogResponse obj cb = connectDialogResponse obj cb SignalConnectAfter++connectDialogResponse :: (GObject a, MonadIO m) =>+                         a -> DialogResponseCallback -> SignalConnectMode -> m SignalHandlerId+connectDialogResponse obj cb after = liftIO $ do+    cb' <- mkDialogResponseCallback (dialogResponseCallbackWrapper cb)+    connectSignalFunPtr obj "response" cb' after++-- VVV Prop "use-header-bar"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDialogUseHeaderBar :: (MonadIO m, DialogK o) => o -> m Int32+getDialogUseHeaderBar obj = liftIO $ getObjectPropertyCInt obj "use-header-bar"++constructDialogUseHeaderBar :: Int32 -> IO ([Char], GValue)+constructDialogUseHeaderBar val = constructObjectPropertyCInt "use-header-bar" val++data DialogUseHeaderBarPropertyInfo+instance AttrInfo DialogUseHeaderBarPropertyInfo where+    type AttrAllowedOps DialogUseHeaderBarPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DialogUseHeaderBarPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint DialogUseHeaderBarPropertyInfo = DialogK+    type AttrGetType DialogUseHeaderBarPropertyInfo = Int32+    type AttrLabel DialogUseHeaderBarPropertyInfo = "Dialog::use-header-bar"+    attrGet _ = getDialogUseHeaderBar+    attrSet _ = undefined+    attrConstruct _ = constructDialogUseHeaderBar++type instance AttributeList Dialog = DialogAttributeList+type DialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++data DialogCloseSignalInfo+instance SignalInfo DialogCloseSignalInfo where+    type HaskellCallbackType DialogCloseSignalInfo = DialogCloseCallback+    connectSignal _ = connectDialogClose++data DialogResponseSignalInfo+instance SignalInfo DialogResponseSignalInfo where+    type HaskellCallbackType DialogResponseSignalInfo = DialogResponseCallback+    connectSignal _ = connectDialogResponse++type instance SignalList Dialog = DialogSignalList+type DialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Dialog::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Dialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_new" gtk_dialog_new :: +    IO (Ptr Dialog)+++dialogNew ::+    (MonadIO m) =>+    m Dialog+dialogNew  = liftIO $ do+    result <- gtk_dialog_new+    checkUnexpectedReturnNULL "gtk_dialog_new" result+    result' <- (newObject Dialog) result+    return result'++-- method Dialog::add_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_dialog_add_action_widget" gtk_dialog_add_action_widget :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++dialogAddActionWidget ::+    (MonadIO m, DialogK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- response_id+    m ()+dialogAddActionWidget _obj child response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_dialog_add_action_widget _obj' child' response_id+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Dialog::add_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_add_button" gtk_dialog_add_button :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    CString ->                              -- button_text : TBasicType TUTF8+    Int32 ->                                -- response_id : TBasicType TInt32+    IO (Ptr Widget)+++dialogAddButton ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- button_text+    Int32 ->                                -- response_id+    m Widget+dialogAddButton _obj button_text response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    button_text' <- textToCString button_text+    result <- gtk_dialog_add_button _obj' button_text' response_id+    checkUnexpectedReturnNULL "gtk_dialog_add_button" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    freeMem button_text'+    return result'++-- method Dialog::get_action_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_get_action_area" gtk_dialog_get_action_area :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    IO (Ptr Widget)++{-# DEPRECATED dialogGetActionArea ["(Since version 3.12)","Direct access to the action area","  is discouraged; use gtk_dialog_add_button(), etc."]#-}+dialogGetActionArea ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    m Widget+dialogGetActionArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_dialog_get_action_area _obj'+    checkUnexpectedReturnNULL "gtk_dialog_get_action_area" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Dialog::get_content_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Box"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_get_content_area" gtk_dialog_get_content_area :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    IO (Ptr Box)+++dialogGetContentArea ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    m Box+dialogGetContentArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_dialog_get_content_area _obj'+    checkUnexpectedReturnNULL "gtk_dialog_get_content_area" result+    result' <- (newObject Box) result+    touchManagedPtr _obj+    return result'++-- method Dialog::get_header_bar+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_get_header_bar" gtk_dialog_get_header_bar :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    IO (Ptr Widget)+++dialogGetHeaderBar ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    m Widget+dialogGetHeaderBar _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_dialog_get_header_bar _obj'+    checkUnexpectedReturnNULL "gtk_dialog_get_header_bar" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Dialog::get_response_for_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_get_response_for_widget" gtk_dialog_get_response_for_widget :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO Int32+++dialogGetResponseForWidget ::+    (MonadIO m, DialogK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m Int32+dialogGetResponseForWidget _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_dialog_get_response_for_widget _obj' widget'+    touchManagedPtr _obj+    touchManagedPtr widget+    return result++-- method Dialog::get_widget_for_response+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_get_widget_for_response" gtk_dialog_get_widget_for_response :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO (Ptr Widget)+++dialogGetWidgetForResponse ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    m Widget+dialogGetWidgetForResponse _obj response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_dialog_get_widget_for_response _obj' response_id+    checkUnexpectedReturnNULL "gtk_dialog_get_widget_for_response" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Dialog::response+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_dialog_response" gtk_dialog_response :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++dialogResponse ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    m ()+dialogResponse _obj response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_dialog_response _obj' response_id+    touchManagedPtr _obj+    return ()++-- method Dialog::run+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_dialog_run" gtk_dialog_run :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    IO Int32+++dialogRun ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    m Int32+dialogRun _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_dialog_run _obj'+    touchManagedPtr _obj+    return result++-- method Dialog::set_alternative_button_order_from_array+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_params", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray False (-1) 1 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_params", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray False (-1) 1 (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 "gtk_dialog_set_alternative_button_order_from_array" gtk_dialog_set_alternative_button_order_from_array :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Int32 ->                                -- n_params : TBasicType TInt32+    Ptr Int32 ->                            -- new_order : TCArray False (-1) 1 (TBasicType TInt32)+    IO ()++{-# DEPRECATED dialogSetAlternativeButtonOrderFromArray ["(Since version 3.10)","Deprecated"]#-}+dialogSetAlternativeButtonOrderFromArray ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    [Int32] ->                              -- new_order+    m ()+dialogSetAlternativeButtonOrderFromArray _obj new_order = liftIO $ do+    let n_params = fromIntegral $ length new_order+    let _obj' = unsafeManagedPtrCastPtr _obj+    new_order' <- packStorableArray new_order+    gtk_dialog_set_alternative_button_order_from_array _obj' n_params new_order'+    touchManagedPtr _obj+    freeMem new_order'+    return ()++-- method Dialog::set_default_response+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_dialog_set_default_response" gtk_dialog_set_default_response :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++dialogSetDefaultResponse ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    m ()+dialogSetDefaultResponse _obj response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_dialog_set_default_response _obj' response_id+    touchManagedPtr _obj+    return ()++-- method Dialog::set_response_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_dialog_set_response_sensitive" gtk_dialog_set_response_sensitive :: +    Ptr Dialog ->                           -- _obj : TInterface "Gtk" "Dialog"+    Int32 ->                                -- response_id : TBasicType TInt32+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++dialogSetResponseSensitive ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    Bool ->                                 -- setting+    m ()+dialogSetResponseSensitive _obj response_id setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_dialog_set_response_sensitive _obj' response_id setting'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Dialog.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.Dialog where++import Prelude ()+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 Dialog = Dialog (ForeignPtr Dialog)+instance GObject Dialog where+class GObject o => DialogK o+instance (GObject o, IsDescendantOf Dialog o) => DialogK o+data DialogUseHeaderBarPropertyInfo+data DialogCloseSignalInfo+data DialogResponseSignalInfo
+ GI/Gtk/Objects/DrawingArea.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.Gtk.Objects.DrawingArea+    ( ++-- * Exported types+    DrawingArea(..)                         ,+    DrawingAreaK                            ,+    toDrawingArea                           ,+    noDrawingArea                           ,+++ -- * Methods+-- ** drawingAreaNew+    drawingAreaNew                          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype DrawingArea = DrawingArea (ForeignPtr DrawingArea)+foreign import ccall "gtk_drawing_area_get_type"+    c_gtk_drawing_area_get_type :: IO GType++type instance ParentTypes DrawingArea = DrawingAreaParentTypes+type DrawingAreaParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject DrawingArea where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_drawing_area_get_type+    ++class GObject o => DrawingAreaK o+instance (GObject o, IsDescendantOf DrawingArea o) => DrawingAreaK o++toDrawingArea :: DrawingAreaK o => o -> IO DrawingArea+toDrawingArea = unsafeCastTo DrawingArea++noDrawingArea :: Maybe DrawingArea+noDrawingArea = Nothing++type instance AttributeList DrawingArea = DrawingAreaAttributeList+type DrawingAreaAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DrawingArea = DrawingAreaSignalList+type DrawingAreaSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DrawingArea::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "DrawingArea"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_drawing_area_new" gtk_drawing_area_new :: +    IO (Ptr DrawingArea)+++drawingAreaNew ::+    (MonadIO m) =>+    m DrawingArea+drawingAreaNew  = liftIO $ do+    result <- gtk_drawing_area_new+    checkUnexpectedReturnNULL "gtk_drawing_area_new" result+    result' <- (newObject DrawingArea) result+    return result'++
+ GI/Gtk/Objects/DrawingArea.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.DrawingArea where++import Prelude ()+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 DrawingArea = DrawingArea (ForeignPtr DrawingArea)+instance GObject DrawingArea where+class GObject o => DrawingAreaK o+instance (GObject o, IsDescendantOf DrawingArea o) => DrawingAreaK o
+ GI/Gtk/Objects/Entry.hs view
@@ -0,0 +1,4698 @@++{- |+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.Gtk.Objects.Entry+    ( ++-- * Exported types+    Entry(..)                               ,+    EntryK                                  ,+    toEntry                                 ,+    noEntry                                 ,+++ -- * Methods+-- ** entryGetActivatesDefault+    entryGetActivatesDefault                ,+++-- ** entryGetAlignment+    entryGetAlignment                       ,+++-- ** entryGetAttributes+    entryGetAttributes                      ,+++-- ** entryGetBuffer+    entryGetBuffer                          ,+++-- ** entryGetCompletion+    entryGetCompletion                      ,+++-- ** entryGetCurrentIconDragSource+    entryGetCurrentIconDragSource           ,+++-- ** entryGetCursorHadjustment+    entryGetCursorHadjustment               ,+++-- ** entryGetHasFrame+    entryGetHasFrame                        ,+++-- ** entryGetIconActivatable+    entryGetIconActivatable                 ,+++-- ** entryGetIconArea+    entryGetIconArea                        ,+++-- ** entryGetIconAtPos+    entryGetIconAtPos                       ,+++-- ** entryGetIconGicon+    entryGetIconGicon                       ,+++-- ** entryGetIconName+    entryGetIconName                        ,+++-- ** entryGetIconPixbuf+    entryGetIconPixbuf                      ,+++-- ** entryGetIconSensitive+    entryGetIconSensitive                   ,+++-- ** entryGetIconStock+    entryGetIconStock                       ,+++-- ** entryGetIconStorageType+    entryGetIconStorageType                 ,+++-- ** entryGetIconTooltipMarkup+    entryGetIconTooltipMarkup               ,+++-- ** entryGetIconTooltipText+    entryGetIconTooltipText                 ,+++-- ** entryGetInnerBorder+    entryGetInnerBorder                     ,+++-- ** entryGetInputHints+    entryGetInputHints                      ,+++-- ** entryGetInputPurpose+    entryGetInputPurpose                    ,+++-- ** entryGetInvisibleChar+    entryGetInvisibleChar                   ,+++-- ** entryGetLayout+    entryGetLayout                          ,+++-- ** entryGetLayoutOffsets+    entryGetLayoutOffsets                   ,+++-- ** entryGetMaxLength+    entryGetMaxLength                       ,+++-- ** entryGetMaxWidthChars+    entryGetMaxWidthChars                   ,+++-- ** entryGetOverwriteMode+    entryGetOverwriteMode                   ,+++-- ** entryGetPlaceholderText+    entryGetPlaceholderText                 ,+++-- ** entryGetProgressFraction+    entryGetProgressFraction                ,+++-- ** entryGetProgressPulseStep+    entryGetProgressPulseStep               ,+++-- ** entryGetTabs+    entryGetTabs                            ,+++-- ** entryGetText+    entryGetText                            ,+++-- ** entryGetTextArea+    entryGetTextArea                        ,+++-- ** entryGetTextLength+    entryGetTextLength                      ,+++-- ** entryGetVisibility+    entryGetVisibility                      ,+++-- ** entryGetWidthChars+    entryGetWidthChars                      ,+++-- ** entryGrabFocusWithoutSelecting+    entryGrabFocusWithoutSelecting          ,+++-- ** entryImContextFilterKeypress+    entryImContextFilterKeypress            ,+++-- ** entryLayoutIndexToTextIndex+    entryLayoutIndexToTextIndex             ,+++-- ** entryNew+    entryNew                                ,+++-- ** entryNewWithBuffer+    entryNewWithBuffer                      ,+++-- ** entryProgressPulse+    entryProgressPulse                      ,+++-- ** entryResetImContext+    entryResetImContext                     ,+++-- ** entrySetActivatesDefault+    entrySetActivatesDefault                ,+++-- ** entrySetAlignment+    entrySetAlignment                       ,+++-- ** entrySetAttributes+    entrySetAttributes                      ,+++-- ** entrySetBuffer+    entrySetBuffer                          ,+++-- ** entrySetCompletion+    entrySetCompletion                      ,+++-- ** entrySetCursorHadjustment+    entrySetCursorHadjustment               ,+++-- ** entrySetHasFrame+    entrySetHasFrame                        ,+++-- ** entrySetIconActivatable+    entrySetIconActivatable                 ,+++-- ** entrySetIconDragSource+    entrySetIconDragSource                  ,+++-- ** entrySetIconFromGicon+    entrySetIconFromGicon                   ,+++-- ** entrySetIconFromIconName+    entrySetIconFromIconName                ,+++-- ** entrySetIconFromPixbuf+    entrySetIconFromPixbuf                  ,+++-- ** entrySetIconFromStock+    entrySetIconFromStock                   ,+++-- ** entrySetIconSensitive+    entrySetIconSensitive                   ,+++-- ** entrySetIconTooltipMarkup+    entrySetIconTooltipMarkup               ,+++-- ** entrySetIconTooltipText+    entrySetIconTooltipText                 ,+++-- ** entrySetInnerBorder+    entrySetInnerBorder                     ,+++-- ** entrySetInputHints+    entrySetInputHints                      ,+++-- ** entrySetInputPurpose+    entrySetInputPurpose                    ,+++-- ** entrySetInvisibleChar+    entrySetInvisibleChar                   ,+++-- ** entrySetMaxLength+    entrySetMaxLength                       ,+++-- ** entrySetMaxWidthChars+    entrySetMaxWidthChars                   ,+++-- ** entrySetOverwriteMode+    entrySetOverwriteMode                   ,+++-- ** entrySetPlaceholderText+    entrySetPlaceholderText                 ,+++-- ** entrySetProgressFraction+    entrySetProgressFraction                ,+++-- ** entrySetProgressPulseStep+    entrySetProgressPulseStep               ,+++-- ** entrySetTabs+    entrySetTabs                            ,+++-- ** entrySetText+    entrySetText                            ,+++-- ** entrySetVisibility+    entrySetVisibility                      ,+++-- ** entrySetWidthChars+    entrySetWidthChars                      ,+++-- ** entryTextIndexToLayoutIndex+    entryTextIndexToLayoutIndex             ,+++-- ** entryUnsetInvisibleChar+    entryUnsetInvisibleChar                 ,+++++ -- * Properties+-- ** ActivatesDefault+    EntryActivatesDefaultPropertyInfo       ,+    constructEntryActivatesDefault          ,+    getEntryActivatesDefault                ,+    setEntryActivatesDefault                ,+++-- ** Attributes+    EntryAttributesPropertyInfo             ,+    constructEntryAttributes                ,+    getEntryAttributes                      ,+    setEntryAttributes                      ,+++-- ** Buffer+    EntryBufferPropertyInfo                 ,+    constructEntryBuffer                    ,+    getEntryBuffer                          ,+    setEntryBuffer                          ,+++-- ** CapsLockWarning+    EntryCapsLockWarningPropertyInfo        ,+    constructEntryCapsLockWarning           ,+    getEntryCapsLockWarning                 ,+    setEntryCapsLockWarning                 ,+++-- ** Completion+    EntryCompletionPropertyInfo             ,+    constructEntryCompletion                ,+    getEntryCompletion                      ,+    setEntryCompletion                      ,+++-- ** CursorPosition+    EntryCursorPositionPropertyInfo         ,+    getEntryCursorPosition                  ,+++-- ** Editable+    EntryEditablePropertyInfo               ,+    constructEntryEditable                  ,+    getEntryEditable                        ,+    setEntryEditable                        ,+++-- ** HasFrame+    EntryHasFramePropertyInfo               ,+    constructEntryHasFrame                  ,+    getEntryHasFrame                        ,+    setEntryHasFrame                        ,+++-- ** ImModule+    EntryImModulePropertyInfo               ,+    constructEntryImModule                  ,+    getEntryImModule                        ,+    setEntryImModule                        ,+++-- ** InnerBorder+    EntryInnerBorderPropertyInfo            ,+    constructEntryInnerBorder               ,+    getEntryInnerBorder                     ,+    setEntryInnerBorder                     ,+++-- ** InputHints+    EntryInputHintsPropertyInfo             ,+    constructEntryInputHints                ,+    getEntryInputHints                      ,+    setEntryInputHints                      ,+++-- ** InputPurpose+    EntryInputPurposePropertyInfo           ,+    constructEntryInputPurpose              ,+    getEntryInputPurpose                    ,+    setEntryInputPurpose                    ,+++-- ** InvisibleChar+    EntryInvisibleCharPropertyInfo          ,+    constructEntryInvisibleChar             ,+    getEntryInvisibleChar                   ,+    setEntryInvisibleChar                   ,+++-- ** InvisibleCharSet+    EntryInvisibleCharSetPropertyInfo       ,+    constructEntryInvisibleCharSet          ,+    getEntryInvisibleCharSet                ,+    setEntryInvisibleCharSet                ,+++-- ** MaxLength+    EntryMaxLengthPropertyInfo              ,+    constructEntryMaxLength                 ,+    getEntryMaxLength                       ,+    setEntryMaxLength                       ,+++-- ** MaxWidthChars+    EntryMaxWidthCharsPropertyInfo          ,+    constructEntryMaxWidthChars             ,+    getEntryMaxWidthChars                   ,+    setEntryMaxWidthChars                   ,+++-- ** OverwriteMode+    EntryOverwriteModePropertyInfo          ,+    constructEntryOverwriteMode             ,+    getEntryOverwriteMode                   ,+    setEntryOverwriteMode                   ,+++-- ** PlaceholderText+    EntryPlaceholderTextPropertyInfo        ,+    constructEntryPlaceholderText           ,+    getEntryPlaceholderText                 ,+    setEntryPlaceholderText                 ,+++-- ** PopulateAll+    EntryPopulateAllPropertyInfo            ,+    constructEntryPopulateAll               ,+    getEntryPopulateAll                     ,+    setEntryPopulateAll                     ,+++-- ** PrimaryIconActivatable+    EntryPrimaryIconActivatablePropertyInfo ,+    constructEntryPrimaryIconActivatable    ,+    getEntryPrimaryIconActivatable          ,+    setEntryPrimaryIconActivatable          ,+++-- ** PrimaryIconGicon+    EntryPrimaryIconGiconPropertyInfo       ,+    constructEntryPrimaryIconGicon          ,+    getEntryPrimaryIconGicon                ,+    setEntryPrimaryIconGicon                ,+++-- ** PrimaryIconName+    EntryPrimaryIconNamePropertyInfo        ,+    constructEntryPrimaryIconName           ,+    getEntryPrimaryIconName                 ,+    setEntryPrimaryIconName                 ,+++-- ** PrimaryIconPixbuf+    EntryPrimaryIconPixbufPropertyInfo      ,+    constructEntryPrimaryIconPixbuf         ,+    getEntryPrimaryIconPixbuf               ,+    setEntryPrimaryIconPixbuf               ,+++-- ** PrimaryIconSensitive+    EntryPrimaryIconSensitivePropertyInfo   ,+    constructEntryPrimaryIconSensitive      ,+    getEntryPrimaryIconSensitive            ,+    setEntryPrimaryIconSensitive            ,+++-- ** PrimaryIconStock+    EntryPrimaryIconStockPropertyInfo       ,+    constructEntryPrimaryIconStock          ,+    getEntryPrimaryIconStock                ,+    setEntryPrimaryIconStock                ,+++-- ** PrimaryIconStorageType+    EntryPrimaryIconStorageTypePropertyInfo ,+    getEntryPrimaryIconStorageType          ,+++-- ** PrimaryIconTooltipMarkup+    EntryPrimaryIconTooltipMarkupPropertyInfo,+    constructEntryPrimaryIconTooltipMarkup  ,+    getEntryPrimaryIconTooltipMarkup        ,+    setEntryPrimaryIconTooltipMarkup        ,+++-- ** PrimaryIconTooltipText+    EntryPrimaryIconTooltipTextPropertyInfo ,+    constructEntryPrimaryIconTooltipText    ,+    getEntryPrimaryIconTooltipText          ,+    setEntryPrimaryIconTooltipText          ,+++-- ** ProgressFraction+    EntryProgressFractionPropertyInfo       ,+    constructEntryProgressFraction          ,+    getEntryProgressFraction                ,+    setEntryProgressFraction                ,+++-- ** ProgressPulseStep+    EntryProgressPulseStepPropertyInfo      ,+    constructEntryProgressPulseStep         ,+    getEntryProgressPulseStep               ,+    setEntryProgressPulseStep               ,+++-- ** ScrollOffset+    EntryScrollOffsetPropertyInfo           ,+    getEntryScrollOffset                    ,+++-- ** SecondaryIconActivatable+    EntrySecondaryIconActivatablePropertyInfo,+    constructEntrySecondaryIconActivatable  ,+    getEntrySecondaryIconActivatable        ,+    setEntrySecondaryIconActivatable        ,+++-- ** SecondaryIconGicon+    EntrySecondaryIconGiconPropertyInfo     ,+    constructEntrySecondaryIconGicon        ,+    getEntrySecondaryIconGicon              ,+    setEntrySecondaryIconGicon              ,+++-- ** SecondaryIconName+    EntrySecondaryIconNamePropertyInfo      ,+    constructEntrySecondaryIconName         ,+    getEntrySecondaryIconName               ,+    setEntrySecondaryIconName               ,+++-- ** SecondaryIconPixbuf+    EntrySecondaryIconPixbufPropertyInfo    ,+    constructEntrySecondaryIconPixbuf       ,+    getEntrySecondaryIconPixbuf             ,+    setEntrySecondaryIconPixbuf             ,+++-- ** SecondaryIconSensitive+    EntrySecondaryIconSensitivePropertyInfo ,+    constructEntrySecondaryIconSensitive    ,+    getEntrySecondaryIconSensitive          ,+    setEntrySecondaryIconSensitive          ,+++-- ** SecondaryIconStock+    EntrySecondaryIconStockPropertyInfo     ,+    constructEntrySecondaryIconStock        ,+    getEntrySecondaryIconStock              ,+    setEntrySecondaryIconStock              ,+++-- ** SecondaryIconStorageType+    EntrySecondaryIconStorageTypePropertyInfo,+    getEntrySecondaryIconStorageType        ,+++-- ** SecondaryIconTooltipMarkup+    EntrySecondaryIconTooltipMarkupPropertyInfo,+    constructEntrySecondaryIconTooltipMarkup,+    getEntrySecondaryIconTooltipMarkup      ,+    setEntrySecondaryIconTooltipMarkup      ,+++-- ** SecondaryIconTooltipText+    EntrySecondaryIconTooltipTextPropertyInfo,+    constructEntrySecondaryIconTooltipText  ,+    getEntrySecondaryIconTooltipText        ,+    setEntrySecondaryIconTooltipText        ,+++-- ** SelectionBound+    EntrySelectionBoundPropertyInfo         ,+    getEntrySelectionBound                  ,+++-- ** ShadowType+    EntryShadowTypePropertyInfo             ,+    constructEntryShadowType                ,+    getEntryShadowType                      ,+    setEntryShadowType                      ,+++-- ** Tabs+    EntryTabsPropertyInfo                   ,+    constructEntryTabs                      ,+    getEntryTabs                            ,+    setEntryTabs                            ,+++-- ** Text+    EntryTextPropertyInfo                   ,+    constructEntryText                      ,+    getEntryText                            ,+    setEntryText                            ,+++-- ** TextLength+    EntryTextLengthPropertyInfo             ,+    getEntryTextLength                      ,+++-- ** TruncateMultiline+    EntryTruncateMultilinePropertyInfo      ,+    constructEntryTruncateMultiline         ,+    getEntryTruncateMultiline               ,+    setEntryTruncateMultiline               ,+++-- ** Visibility+    EntryVisibilityPropertyInfo             ,+    constructEntryVisibility                ,+    getEntryVisibility                      ,+    setEntryVisibility                      ,+++-- ** WidthChars+    EntryWidthCharsPropertyInfo             ,+    constructEntryWidthChars                ,+    getEntryWidthChars                      ,+    setEntryWidthChars                      ,+++-- ** Xalign+    EntryXalignPropertyInfo                 ,+    constructEntryXalign                    ,+    getEntryXalign                          ,+    setEntryXalign                          ,+++++ -- * Signals+-- ** Activate+    EntryActivateCallback                   ,+    EntryActivateCallbackC                  ,+    EntryActivateSignalInfo                 ,+    afterEntryActivate                      ,+    entryActivateCallbackWrapper            ,+    entryActivateClosure                    ,+    mkEntryActivateCallback                 ,+    noEntryActivateCallback                 ,+    onEntryActivate                         ,+++-- ** Backspace+    EntryBackspaceCallback                  ,+    EntryBackspaceCallbackC                 ,+    EntryBackspaceSignalInfo                ,+    afterEntryBackspace                     ,+    entryBackspaceCallbackWrapper           ,+    entryBackspaceClosure                   ,+    mkEntryBackspaceCallback                ,+    noEntryBackspaceCallback                ,+    onEntryBackspace                        ,+++-- ** CopyClipboard+    EntryCopyClipboardCallback              ,+    EntryCopyClipboardCallbackC             ,+    EntryCopyClipboardSignalInfo            ,+    afterEntryCopyClipboard                 ,+    entryCopyClipboardCallbackWrapper       ,+    entryCopyClipboardClosure               ,+    mkEntryCopyClipboardCallback            ,+    noEntryCopyClipboardCallback            ,+    onEntryCopyClipboard                    ,+++-- ** CutClipboard+    EntryCutClipboardCallback               ,+    EntryCutClipboardCallbackC              ,+    EntryCutClipboardSignalInfo             ,+    afterEntryCutClipboard                  ,+    entryCutClipboardCallbackWrapper        ,+    entryCutClipboardClosure                ,+    mkEntryCutClipboardCallback             ,+    noEntryCutClipboardCallback             ,+    onEntryCutClipboard                     ,+++-- ** DeleteFromCursor+    EntryDeleteFromCursorCallback           ,+    EntryDeleteFromCursorCallbackC          ,+    EntryDeleteFromCursorSignalInfo         ,+    afterEntryDeleteFromCursor              ,+    entryDeleteFromCursorCallbackWrapper    ,+    entryDeleteFromCursorClosure            ,+    mkEntryDeleteFromCursorCallback         ,+    noEntryDeleteFromCursorCallback         ,+    onEntryDeleteFromCursor                 ,+++-- ** IconPress+    EntryIconPressCallback                  ,+    EntryIconPressCallbackC                 ,+    EntryIconPressSignalInfo                ,+    afterEntryIconPress                     ,+    entryIconPressCallbackWrapper           ,+    entryIconPressClosure                   ,+    mkEntryIconPressCallback                ,+    noEntryIconPressCallback                ,+    onEntryIconPress                        ,+++-- ** IconRelease+    EntryIconReleaseCallback                ,+    EntryIconReleaseCallbackC               ,+    EntryIconReleaseSignalInfo              ,+    afterEntryIconRelease                   ,+    entryIconReleaseCallbackWrapper         ,+    entryIconReleaseClosure                 ,+    mkEntryIconReleaseCallback              ,+    noEntryIconReleaseCallback              ,+    onEntryIconRelease                      ,+++-- ** InsertAtCursor+    EntryInsertAtCursorCallback             ,+    EntryInsertAtCursorCallbackC            ,+    EntryInsertAtCursorSignalInfo           ,+    afterEntryInsertAtCursor                ,+    entryInsertAtCursorCallbackWrapper      ,+    entryInsertAtCursorClosure              ,+    mkEntryInsertAtCursorCallback           ,+    noEntryInsertAtCursorCallback           ,+    onEntryInsertAtCursor                   ,+++-- ** MoveCursor+    EntryMoveCursorCallback                 ,+    EntryMoveCursorCallbackC                ,+    EntryMoveCursorSignalInfo               ,+    afterEntryMoveCursor                    ,+    entryMoveCursorCallbackWrapper          ,+    entryMoveCursorClosure                  ,+    mkEntryMoveCursorCallback               ,+    noEntryMoveCursorCallback               ,+    onEntryMoveCursor                       ,+++-- ** PasteClipboard+    EntryPasteClipboardCallback             ,+    EntryPasteClipboardCallbackC            ,+    EntryPasteClipboardSignalInfo           ,+    afterEntryPasteClipboard                ,+    entryPasteClipboardCallbackWrapper      ,+    entryPasteClipboardClosure              ,+    mkEntryPasteClipboardCallback           ,+    noEntryPasteClipboardCallback           ,+    onEntryPasteClipboard                   ,+++-- ** PopulatePopup+    EntryPopulatePopupCallback              ,+    EntryPopulatePopupCallbackC             ,+    EntryPopulatePopupSignalInfo            ,+    afterEntryPopulatePopup                 ,+    entryPopulatePopupCallbackWrapper       ,+    entryPopulatePopupClosure               ,+    mkEntryPopulatePopupCallback            ,+    noEntryPopulatePopupCallback            ,+    onEntryPopulatePopup                    ,+++-- ** PreeditChanged+    EntryPreeditChangedCallback             ,+    EntryPreeditChangedCallbackC            ,+    EntryPreeditChangedSignalInfo           ,+    afterEntryPreeditChanged                ,+    entryPreeditChangedCallbackWrapper      ,+    entryPreeditChangedClosure              ,+    mkEntryPreeditChangedCallback           ,+    noEntryPreeditChangedCallback           ,+    onEntryPreeditChanged                   ,+++-- ** ToggleOverwrite+    EntryToggleOverwriteCallback            ,+    EntryToggleOverwriteCallbackC           ,+    EntryToggleOverwriteSignalInfo          ,+    afterEntryToggleOverwrite               ,+    entryToggleOverwriteCallbackWrapper     ,+    entryToggleOverwriteClosure             ,+    mkEntryToggleOverwriteCallback          ,+    noEntryToggleOverwriteCallback          ,+    onEntryToggleOverwrite                  ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Pango as Pango++newtype Entry = Entry (ForeignPtr Entry)+foreign import ccall "gtk_entry_get_type"+    c_gtk_entry_get_type :: IO GType++type instance ParentTypes Entry = EntryParentTypes+type EntryParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable, CellEditable, Editable]++instance GObject Entry where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_entry_get_type+    ++class GObject o => EntryK o+instance (GObject o, IsDescendantOf Entry o) => EntryK o++toEntry :: EntryK o => o -> IO Entry+toEntry = unsafeCastTo Entry++noEntry :: Maybe Entry+noEntry = Nothing++-- signal Entry::activate+type EntryActivateCallback =+    IO ()++noEntryActivateCallback :: Maybe EntryActivateCallback+noEntryActivateCallback = Nothing++type EntryActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryActivateCallback :: EntryActivateCallbackC -> IO (FunPtr EntryActivateCallbackC)++entryActivateClosure :: EntryActivateCallback -> IO Closure+entryActivateClosure cb = newCClosure =<< mkEntryActivateCallback wrapped+    where wrapped = entryActivateCallbackWrapper cb++entryActivateCallbackWrapper ::+    EntryActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryActivateCallbackWrapper _cb _ _ = do+    _cb ++onEntryActivate :: (GObject a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId+onEntryActivate obj cb = liftIO $ connectEntryActivate obj cb SignalConnectBefore+afterEntryActivate :: (GObject a, MonadIO m) => a -> EntryActivateCallback -> m SignalHandlerId+afterEntryActivate obj cb = connectEntryActivate obj cb SignalConnectAfter++connectEntryActivate :: (GObject a, MonadIO m) =>+                        a -> EntryActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryActivate obj cb after = liftIO $ do+    cb' <- mkEntryActivateCallback (entryActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- signal Entry::backspace+type EntryBackspaceCallback =+    IO ()++noEntryBackspaceCallback :: Maybe EntryBackspaceCallback+noEntryBackspaceCallback = Nothing++type EntryBackspaceCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryBackspaceCallback :: EntryBackspaceCallbackC -> IO (FunPtr EntryBackspaceCallbackC)++entryBackspaceClosure :: EntryBackspaceCallback -> IO Closure+entryBackspaceClosure cb = newCClosure =<< mkEntryBackspaceCallback wrapped+    where wrapped = entryBackspaceCallbackWrapper cb++entryBackspaceCallbackWrapper ::+    EntryBackspaceCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryBackspaceCallbackWrapper _cb _ _ = do+    _cb ++onEntryBackspace :: (GObject a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId+onEntryBackspace obj cb = liftIO $ connectEntryBackspace obj cb SignalConnectBefore+afterEntryBackspace :: (GObject a, MonadIO m) => a -> EntryBackspaceCallback -> m SignalHandlerId+afterEntryBackspace obj cb = connectEntryBackspace obj cb SignalConnectAfter++connectEntryBackspace :: (GObject a, MonadIO m) =>+                         a -> EntryBackspaceCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryBackspace obj cb after = liftIO $ do+    cb' <- mkEntryBackspaceCallback (entryBackspaceCallbackWrapper cb)+    connectSignalFunPtr obj "backspace" cb' after++-- signal Entry::copy-clipboard+type EntryCopyClipboardCallback =+    IO ()++noEntryCopyClipboardCallback :: Maybe EntryCopyClipboardCallback+noEntryCopyClipboardCallback = Nothing++type EntryCopyClipboardCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryCopyClipboardCallback :: EntryCopyClipboardCallbackC -> IO (FunPtr EntryCopyClipboardCallbackC)++entryCopyClipboardClosure :: EntryCopyClipboardCallback -> IO Closure+entryCopyClipboardClosure cb = newCClosure =<< mkEntryCopyClipboardCallback wrapped+    where wrapped = entryCopyClipboardCallbackWrapper cb++entryCopyClipboardCallbackWrapper ::+    EntryCopyClipboardCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryCopyClipboardCallbackWrapper _cb _ _ = do+    _cb ++onEntryCopyClipboard :: (GObject a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId+onEntryCopyClipboard obj cb = liftIO $ connectEntryCopyClipboard obj cb SignalConnectBefore+afterEntryCopyClipboard :: (GObject a, MonadIO m) => a -> EntryCopyClipboardCallback -> m SignalHandlerId+afterEntryCopyClipboard obj cb = connectEntryCopyClipboard obj cb SignalConnectAfter++connectEntryCopyClipboard :: (GObject a, MonadIO m) =>+                             a -> EntryCopyClipboardCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCopyClipboard obj cb after = liftIO $ do+    cb' <- mkEntryCopyClipboardCallback (entryCopyClipboardCallbackWrapper cb)+    connectSignalFunPtr obj "copy-clipboard" cb' after++-- signal Entry::cut-clipboard+type EntryCutClipboardCallback =+    IO ()++noEntryCutClipboardCallback :: Maybe EntryCutClipboardCallback+noEntryCutClipboardCallback = Nothing++type EntryCutClipboardCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryCutClipboardCallback :: EntryCutClipboardCallbackC -> IO (FunPtr EntryCutClipboardCallbackC)++entryCutClipboardClosure :: EntryCutClipboardCallback -> IO Closure+entryCutClipboardClosure cb = newCClosure =<< mkEntryCutClipboardCallback wrapped+    where wrapped = entryCutClipboardCallbackWrapper cb++entryCutClipboardCallbackWrapper ::+    EntryCutClipboardCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryCutClipboardCallbackWrapper _cb _ _ = do+    _cb ++onEntryCutClipboard :: (GObject a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId+onEntryCutClipboard obj cb = liftIO $ connectEntryCutClipboard obj cb SignalConnectBefore+afterEntryCutClipboard :: (GObject a, MonadIO m) => a -> EntryCutClipboardCallback -> m SignalHandlerId+afterEntryCutClipboard obj cb = connectEntryCutClipboard obj cb SignalConnectAfter++connectEntryCutClipboard :: (GObject a, MonadIO m) =>+                            a -> EntryCutClipboardCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCutClipboard obj cb after = liftIO $ do+    cb' <- mkEntryCutClipboardCallback (entryCutClipboardCallbackWrapper cb)+    connectSignalFunPtr obj "cut-clipboard" cb' after++-- signal Entry::delete-from-cursor+type EntryDeleteFromCursorCallback =+    DeleteType ->+    Int32 ->+    IO ()++noEntryDeleteFromCursorCallback :: Maybe EntryDeleteFromCursorCallback+noEntryDeleteFromCursorCallback = Nothing++type EntryDeleteFromCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryDeleteFromCursorCallback :: EntryDeleteFromCursorCallbackC -> IO (FunPtr EntryDeleteFromCursorCallbackC)++entryDeleteFromCursorClosure :: EntryDeleteFromCursorCallback -> IO Closure+entryDeleteFromCursorClosure cb = newCClosure =<< mkEntryDeleteFromCursorCallback wrapped+    where wrapped = entryDeleteFromCursorCallbackWrapper cb++entryDeleteFromCursorCallbackWrapper ::+    EntryDeleteFromCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    Ptr () ->+    IO ()+entryDeleteFromCursorCallbackWrapper _cb _ type_ count _ = do+    let type_' = (toEnum . fromIntegral) type_+    _cb  type_' count++onEntryDeleteFromCursor :: (GObject a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId+onEntryDeleteFromCursor obj cb = liftIO $ connectEntryDeleteFromCursor obj cb SignalConnectBefore+afterEntryDeleteFromCursor :: (GObject a, MonadIO m) => a -> EntryDeleteFromCursorCallback -> m SignalHandlerId+afterEntryDeleteFromCursor obj cb = connectEntryDeleteFromCursor obj cb SignalConnectAfter++connectEntryDeleteFromCursor :: (GObject a, MonadIO m) =>+                                a -> EntryDeleteFromCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryDeleteFromCursor obj cb after = liftIO $ do+    cb' <- mkEntryDeleteFromCursorCallback (entryDeleteFromCursorCallbackWrapper cb)+    connectSignalFunPtr obj "delete-from-cursor" cb' after++-- signal Entry::icon-press+type EntryIconPressCallback =+    EntryIconPosition ->+    Gdk.EventButton ->+    IO ()++noEntryIconPressCallback :: Maybe EntryIconPressCallback+noEntryIconPressCallback = Nothing++type EntryIconPressCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr Gdk.EventButton ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryIconPressCallback :: EntryIconPressCallbackC -> IO (FunPtr EntryIconPressCallbackC)++entryIconPressClosure :: EntryIconPressCallback -> IO Closure+entryIconPressClosure cb = newCClosure =<< mkEntryIconPressCallback wrapped+    where wrapped = entryIconPressCallbackWrapper cb++entryIconPressCallbackWrapper ::+    EntryIconPressCallback ->+    Ptr () ->+    CUInt ->+    Ptr Gdk.EventButton ->+    Ptr () ->+    IO ()+entryIconPressCallbackWrapper _cb _ icon_pos event _ = do+    let icon_pos' = (toEnum . fromIntegral) icon_pos+    event' <- (newPtr 80 Gdk.EventButton) event+    _cb  icon_pos' event'++onEntryIconPress :: (GObject a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId+onEntryIconPress obj cb = liftIO $ connectEntryIconPress obj cb SignalConnectBefore+afterEntryIconPress :: (GObject a, MonadIO m) => a -> EntryIconPressCallback -> m SignalHandlerId+afterEntryIconPress obj cb = connectEntryIconPress obj cb SignalConnectAfter++connectEntryIconPress :: (GObject a, MonadIO m) =>+                         a -> EntryIconPressCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryIconPress obj cb after = liftIO $ do+    cb' <- mkEntryIconPressCallback (entryIconPressCallbackWrapper cb)+    connectSignalFunPtr obj "icon-press" cb' after++-- signal Entry::icon-release+type EntryIconReleaseCallback =+    EntryIconPosition ->+    Gdk.EventButton ->+    IO ()++noEntryIconReleaseCallback :: Maybe EntryIconReleaseCallback+noEntryIconReleaseCallback = Nothing++type EntryIconReleaseCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr Gdk.EventButton ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryIconReleaseCallback :: EntryIconReleaseCallbackC -> IO (FunPtr EntryIconReleaseCallbackC)++entryIconReleaseClosure :: EntryIconReleaseCallback -> IO Closure+entryIconReleaseClosure cb = newCClosure =<< mkEntryIconReleaseCallback wrapped+    where wrapped = entryIconReleaseCallbackWrapper cb++entryIconReleaseCallbackWrapper ::+    EntryIconReleaseCallback ->+    Ptr () ->+    CUInt ->+    Ptr Gdk.EventButton ->+    Ptr () ->+    IO ()+entryIconReleaseCallbackWrapper _cb _ icon_pos event _ = do+    let icon_pos' = (toEnum . fromIntegral) icon_pos+    event' <- (newPtr 80 Gdk.EventButton) event+    _cb  icon_pos' event'++onEntryIconRelease :: (GObject a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId+onEntryIconRelease obj cb = liftIO $ connectEntryIconRelease obj cb SignalConnectBefore+afterEntryIconRelease :: (GObject a, MonadIO m) => a -> EntryIconReleaseCallback -> m SignalHandlerId+afterEntryIconRelease obj cb = connectEntryIconRelease obj cb SignalConnectAfter++connectEntryIconRelease :: (GObject a, MonadIO m) =>+                           a -> EntryIconReleaseCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryIconRelease obj cb after = liftIO $ do+    cb' <- mkEntryIconReleaseCallback (entryIconReleaseCallbackWrapper cb)+    connectSignalFunPtr obj "icon-release" cb' after++-- signal Entry::insert-at-cursor+type EntryInsertAtCursorCallback =+    T.Text ->+    IO ()++noEntryInsertAtCursorCallback :: Maybe EntryInsertAtCursorCallback+noEntryInsertAtCursorCallback = Nothing++type EntryInsertAtCursorCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryInsertAtCursorCallback :: EntryInsertAtCursorCallbackC -> IO (FunPtr EntryInsertAtCursorCallbackC)++entryInsertAtCursorClosure :: EntryInsertAtCursorCallback -> IO Closure+entryInsertAtCursorClosure cb = newCClosure =<< mkEntryInsertAtCursorCallback wrapped+    where wrapped = entryInsertAtCursorCallbackWrapper cb++entryInsertAtCursorCallbackWrapper ::+    EntryInsertAtCursorCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+entryInsertAtCursorCallbackWrapper _cb _ string _ = do+    string' <- cstringToText string+    _cb  string'++onEntryInsertAtCursor :: (GObject a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId+onEntryInsertAtCursor obj cb = liftIO $ connectEntryInsertAtCursor obj cb SignalConnectBefore+afterEntryInsertAtCursor :: (GObject a, MonadIO m) => a -> EntryInsertAtCursorCallback -> m SignalHandlerId+afterEntryInsertAtCursor obj cb = connectEntryInsertAtCursor obj cb SignalConnectAfter++connectEntryInsertAtCursor :: (GObject a, MonadIO m) =>+                              a -> EntryInsertAtCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryInsertAtCursor obj cb after = liftIO $ do+    cb' <- mkEntryInsertAtCursorCallback (entryInsertAtCursorCallbackWrapper cb)+    connectSignalFunPtr obj "insert-at-cursor" cb' after++-- signal Entry::move-cursor+type EntryMoveCursorCallback =+    MovementStep ->+    Int32 ->+    Bool ->+    IO ()++noEntryMoveCursorCallback :: Maybe EntryMoveCursorCallback+noEntryMoveCursorCallback = Nothing++type EntryMoveCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryMoveCursorCallback :: EntryMoveCursorCallbackC -> IO (FunPtr EntryMoveCursorCallbackC)++entryMoveCursorClosure :: EntryMoveCursorCallback -> IO Closure+entryMoveCursorClosure cb = newCClosure =<< mkEntryMoveCursorCallback wrapped+    where wrapped = entryMoveCursorCallbackWrapper cb++entryMoveCursorCallbackWrapper ::+    EntryMoveCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    CInt ->+    Ptr () ->+    IO ()+entryMoveCursorCallbackWrapper _cb _ step count extend_selection _ = do+    let step' = (toEnum . fromIntegral) step+    let extend_selection' = (/= 0) extend_selection+    _cb  step' count extend_selection'++onEntryMoveCursor :: (GObject a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId+onEntryMoveCursor obj cb = liftIO $ connectEntryMoveCursor obj cb SignalConnectBefore+afterEntryMoveCursor :: (GObject a, MonadIO m) => a -> EntryMoveCursorCallback -> m SignalHandlerId+afterEntryMoveCursor obj cb = connectEntryMoveCursor obj cb SignalConnectAfter++connectEntryMoveCursor :: (GObject a, MonadIO m) =>+                          a -> EntryMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryMoveCursor obj cb after = liftIO $ do+    cb' <- mkEntryMoveCursorCallback (entryMoveCursorCallbackWrapper cb)+    connectSignalFunPtr obj "move-cursor" cb' after++-- signal Entry::paste-clipboard+type EntryPasteClipboardCallback =+    IO ()++noEntryPasteClipboardCallback :: Maybe EntryPasteClipboardCallback+noEntryPasteClipboardCallback = Nothing++type EntryPasteClipboardCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryPasteClipboardCallback :: EntryPasteClipboardCallbackC -> IO (FunPtr EntryPasteClipboardCallbackC)++entryPasteClipboardClosure :: EntryPasteClipboardCallback -> IO Closure+entryPasteClipboardClosure cb = newCClosure =<< mkEntryPasteClipboardCallback wrapped+    where wrapped = entryPasteClipboardCallbackWrapper cb++entryPasteClipboardCallbackWrapper ::+    EntryPasteClipboardCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryPasteClipboardCallbackWrapper _cb _ _ = do+    _cb ++onEntryPasteClipboard :: (GObject a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId+onEntryPasteClipboard obj cb = liftIO $ connectEntryPasteClipboard obj cb SignalConnectBefore+afterEntryPasteClipboard :: (GObject a, MonadIO m) => a -> EntryPasteClipboardCallback -> m SignalHandlerId+afterEntryPasteClipboard obj cb = connectEntryPasteClipboard obj cb SignalConnectAfter++connectEntryPasteClipboard :: (GObject a, MonadIO m) =>+                              a -> EntryPasteClipboardCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryPasteClipboard obj cb after = liftIO $ do+    cb' <- mkEntryPasteClipboardCallback (entryPasteClipboardCallbackWrapper cb)+    connectSignalFunPtr obj "paste-clipboard" cb' after++-- signal Entry::populate-popup+type EntryPopulatePopupCallback =+    Widget ->+    IO ()++noEntryPopulatePopupCallback :: Maybe EntryPopulatePopupCallback+noEntryPopulatePopupCallback = Nothing++type EntryPopulatePopupCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryPopulatePopupCallback :: EntryPopulatePopupCallbackC -> IO (FunPtr EntryPopulatePopupCallbackC)++entryPopulatePopupClosure :: EntryPopulatePopupCallback -> IO Closure+entryPopulatePopupClosure cb = newCClosure =<< mkEntryPopulatePopupCallback wrapped+    where wrapped = entryPopulatePopupCallbackWrapper cb++entryPopulatePopupCallbackWrapper ::+    EntryPopulatePopupCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+entryPopulatePopupCallbackWrapper _cb _ popup _ = do+    popup' <- (newObject Widget) popup+    _cb  popup'++onEntryPopulatePopup :: (GObject a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId+onEntryPopulatePopup obj cb = liftIO $ connectEntryPopulatePopup obj cb SignalConnectBefore+afterEntryPopulatePopup :: (GObject a, MonadIO m) => a -> EntryPopulatePopupCallback -> m SignalHandlerId+afterEntryPopulatePopup obj cb = connectEntryPopulatePopup obj cb SignalConnectAfter++connectEntryPopulatePopup :: (GObject a, MonadIO m) =>+                             a -> EntryPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryPopulatePopup obj cb after = liftIO $ do+    cb' <- mkEntryPopulatePopupCallback (entryPopulatePopupCallbackWrapper cb)+    connectSignalFunPtr obj "populate-popup" cb' after++-- signal Entry::preedit-changed+type EntryPreeditChangedCallback =+    T.Text ->+    IO ()++noEntryPreeditChangedCallback :: Maybe EntryPreeditChangedCallback+noEntryPreeditChangedCallback = Nothing++type EntryPreeditChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryPreeditChangedCallback :: EntryPreeditChangedCallbackC -> IO (FunPtr EntryPreeditChangedCallbackC)++entryPreeditChangedClosure :: EntryPreeditChangedCallback -> IO Closure+entryPreeditChangedClosure cb = newCClosure =<< mkEntryPreeditChangedCallback wrapped+    where wrapped = entryPreeditChangedCallbackWrapper cb++entryPreeditChangedCallbackWrapper ::+    EntryPreeditChangedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+entryPreeditChangedCallbackWrapper _cb _ preedit _ = do+    preedit' <- cstringToText preedit+    _cb  preedit'++onEntryPreeditChanged :: (GObject a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId+onEntryPreeditChanged obj cb = liftIO $ connectEntryPreeditChanged obj cb SignalConnectBefore+afterEntryPreeditChanged :: (GObject a, MonadIO m) => a -> EntryPreeditChangedCallback -> m SignalHandlerId+afterEntryPreeditChanged obj cb = connectEntryPreeditChanged obj cb SignalConnectAfter++connectEntryPreeditChanged :: (GObject a, MonadIO m) =>+                              a -> EntryPreeditChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryPreeditChanged obj cb after = liftIO $ do+    cb' <- mkEntryPreeditChangedCallback (entryPreeditChangedCallbackWrapper cb)+    connectSignalFunPtr obj "preedit-changed" cb' after++-- signal Entry::toggle-overwrite+type EntryToggleOverwriteCallback =+    IO ()++noEntryToggleOverwriteCallback :: Maybe EntryToggleOverwriteCallback+noEntryToggleOverwriteCallback = Nothing++type EntryToggleOverwriteCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryToggleOverwriteCallback :: EntryToggleOverwriteCallbackC -> IO (FunPtr EntryToggleOverwriteCallbackC)++entryToggleOverwriteClosure :: EntryToggleOverwriteCallback -> IO Closure+entryToggleOverwriteClosure cb = newCClosure =<< mkEntryToggleOverwriteCallback wrapped+    where wrapped = entryToggleOverwriteCallbackWrapper cb++entryToggleOverwriteCallbackWrapper ::+    EntryToggleOverwriteCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryToggleOverwriteCallbackWrapper _cb _ _ = do+    _cb ++onEntryToggleOverwrite :: (GObject a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId+onEntryToggleOverwrite obj cb = liftIO $ connectEntryToggleOverwrite obj cb SignalConnectBefore+afterEntryToggleOverwrite :: (GObject a, MonadIO m) => a -> EntryToggleOverwriteCallback -> m SignalHandlerId+afterEntryToggleOverwrite obj cb = connectEntryToggleOverwrite obj cb SignalConnectAfter++connectEntryToggleOverwrite :: (GObject a, MonadIO m) =>+                               a -> EntryToggleOverwriteCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryToggleOverwrite obj cb after = liftIO $ do+    cb' <- mkEntryToggleOverwriteCallback (entryToggleOverwriteCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-overwrite" cb' after++-- VVV Prop "activates-default"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryActivatesDefault :: (MonadIO m, EntryK o) => o -> m Bool+getEntryActivatesDefault obj = liftIO $ getObjectPropertyBool obj "activates-default"++setEntryActivatesDefault :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryActivatesDefault obj val = liftIO $ setObjectPropertyBool obj "activates-default" val++constructEntryActivatesDefault :: Bool -> IO ([Char], GValue)+constructEntryActivatesDefault val = constructObjectPropertyBool "activates-default" val++data EntryActivatesDefaultPropertyInfo+instance AttrInfo EntryActivatesDefaultPropertyInfo where+    type AttrAllowedOps EntryActivatesDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryActivatesDefaultPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryActivatesDefaultPropertyInfo = EntryK+    type AttrGetType EntryActivatesDefaultPropertyInfo = Bool+    type AttrLabel EntryActivatesDefaultPropertyInfo = "Entry::activates-default"+    attrGet _ = getEntryActivatesDefault+    attrSet _ = setEntryActivatesDefault+    attrConstruct _ = constructEntryActivatesDefault++-- VVV Prop "attributes"+   -- Type: TInterface "Pango" "AttrList"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryAttributes :: (MonadIO m, EntryK o) => o -> m Pango.AttrList+getEntryAttributes obj = liftIO $ getObjectPropertyBoxed obj "attributes" Pango.AttrList++setEntryAttributes :: (MonadIO m, EntryK o) => o -> Pango.AttrList -> m ()+setEntryAttributes obj val = liftIO $ setObjectPropertyBoxed obj "attributes" val++constructEntryAttributes :: Pango.AttrList -> IO ([Char], GValue)+constructEntryAttributes val = constructObjectPropertyBoxed "attributes" val++data EntryAttributesPropertyInfo+instance AttrInfo EntryAttributesPropertyInfo where+    type AttrAllowedOps EntryAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryAttributesPropertyInfo = (~) Pango.AttrList+    type AttrBaseTypeConstraint EntryAttributesPropertyInfo = EntryK+    type AttrGetType EntryAttributesPropertyInfo = Pango.AttrList+    type AttrLabel EntryAttributesPropertyInfo = "Entry::attributes"+    attrGet _ = getEntryAttributes+    attrSet _ = setEntryAttributes+    attrConstruct _ = constructEntryAttributes++-- VVV Prop "buffer"+   -- Type: TInterface "Gtk" "EntryBuffer"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getEntryBuffer :: (MonadIO m, EntryK o) => o -> m EntryBuffer+getEntryBuffer obj = liftIO $ getObjectPropertyObject obj "buffer" EntryBuffer++setEntryBuffer :: (MonadIO m, EntryK o, EntryBufferK a) => o -> a -> m ()+setEntryBuffer obj val = liftIO $ setObjectPropertyObject obj "buffer" val++constructEntryBuffer :: (EntryBufferK a) => a -> IO ([Char], GValue)+constructEntryBuffer val = constructObjectPropertyObject "buffer" val++data EntryBufferPropertyInfo+instance AttrInfo EntryBufferPropertyInfo where+    type AttrAllowedOps EntryBufferPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryBufferPropertyInfo = EntryBufferK+    type AttrBaseTypeConstraint EntryBufferPropertyInfo = EntryK+    type AttrGetType EntryBufferPropertyInfo = EntryBuffer+    type AttrLabel EntryBufferPropertyInfo = "Entry::buffer"+    attrGet _ = getEntryBuffer+    attrSet _ = setEntryBuffer+    attrConstruct _ = constructEntryBuffer++-- VVV Prop "caps-lock-warning"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCapsLockWarning :: (MonadIO m, EntryK o) => o -> m Bool+getEntryCapsLockWarning obj = liftIO $ getObjectPropertyBool obj "caps-lock-warning"++setEntryCapsLockWarning :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryCapsLockWarning obj val = liftIO $ setObjectPropertyBool obj "caps-lock-warning" val++constructEntryCapsLockWarning :: Bool -> IO ([Char], GValue)+constructEntryCapsLockWarning val = constructObjectPropertyBool "caps-lock-warning" val++data EntryCapsLockWarningPropertyInfo+instance AttrInfo EntryCapsLockWarningPropertyInfo where+    type AttrAllowedOps EntryCapsLockWarningPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCapsLockWarningPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCapsLockWarningPropertyInfo = EntryK+    type AttrGetType EntryCapsLockWarningPropertyInfo = Bool+    type AttrLabel EntryCapsLockWarningPropertyInfo = "Entry::caps-lock-warning"+    attrGet _ = getEntryCapsLockWarning+    attrSet _ = setEntryCapsLockWarning+    attrConstruct _ = constructEntryCapsLockWarning++-- VVV Prop "completion"+   -- Type: TInterface "Gtk" "EntryCompletion"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletion :: (MonadIO m, EntryK o) => o -> m EntryCompletion+getEntryCompletion obj = liftIO $ getObjectPropertyObject obj "completion" EntryCompletion++setEntryCompletion :: (MonadIO m, EntryK o, EntryCompletionK a) => o -> a -> m ()+setEntryCompletion obj val = liftIO $ setObjectPropertyObject obj "completion" val++constructEntryCompletion :: (EntryCompletionK a) => a -> IO ([Char], GValue)+constructEntryCompletion val = constructObjectPropertyObject "completion" val++data EntryCompletionPropertyInfo+instance AttrInfo EntryCompletionPropertyInfo where+    type AttrAllowedOps EntryCompletionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionPropertyInfo = EntryCompletionK+    type AttrBaseTypeConstraint EntryCompletionPropertyInfo = EntryK+    type AttrGetType EntryCompletionPropertyInfo = EntryCompletion+    type AttrLabel EntryCompletionPropertyInfo = "Entry::completion"+    attrGet _ = getEntryCompletion+    attrSet _ = setEntryCompletion+    attrConstruct _ = constructEntryCompletion++-- VVV Prop "cursor-position"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getEntryCursorPosition :: (MonadIO m, EntryK o) => o -> m Int32+getEntryCursorPosition obj = liftIO $ getObjectPropertyCInt obj "cursor-position"++data EntryCursorPositionPropertyInfo+instance AttrInfo EntryCursorPositionPropertyInfo where+    type AttrAllowedOps EntryCursorPositionPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntryCursorPositionPropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntryCursorPositionPropertyInfo = EntryK+    type AttrGetType EntryCursorPositionPropertyInfo = Int32+    type AttrLabel EntryCursorPositionPropertyInfo = "Entry::cursor-position"+    attrGet _ = getEntryCursorPosition+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "editable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryEditable :: (MonadIO m, EntryK o) => o -> m Bool+getEntryEditable obj = liftIO $ getObjectPropertyBool obj "editable"++setEntryEditable :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryEditable obj val = liftIO $ setObjectPropertyBool obj "editable" val++constructEntryEditable :: Bool -> IO ([Char], GValue)+constructEntryEditable val = constructObjectPropertyBool "editable" val++data EntryEditablePropertyInfo+instance AttrInfo EntryEditablePropertyInfo where+    type AttrAllowedOps EntryEditablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryEditablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryEditablePropertyInfo = EntryK+    type AttrGetType EntryEditablePropertyInfo = Bool+    type AttrLabel EntryEditablePropertyInfo = "Entry::editable"+    attrGet _ = getEntryEditable+    attrSet _ = setEntryEditable+    attrConstruct _ = constructEntryEditable++-- VVV Prop "has-frame"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryHasFrame :: (MonadIO m, EntryK o) => o -> m Bool+getEntryHasFrame obj = liftIO $ getObjectPropertyBool obj "has-frame"++setEntryHasFrame :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryHasFrame obj val = liftIO $ setObjectPropertyBool obj "has-frame" val++constructEntryHasFrame :: Bool -> IO ([Char], GValue)+constructEntryHasFrame val = constructObjectPropertyBool "has-frame" val++data EntryHasFramePropertyInfo+instance AttrInfo EntryHasFramePropertyInfo where+    type AttrAllowedOps EntryHasFramePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryHasFramePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryHasFramePropertyInfo = EntryK+    type AttrGetType EntryHasFramePropertyInfo = Bool+    type AttrLabel EntryHasFramePropertyInfo = "Entry::has-frame"+    attrGet _ = getEntryHasFrame+    attrSet _ = setEntryHasFrame+    attrConstruct _ = constructEntryHasFrame++-- VVV Prop "im-module"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryImModule :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryImModule obj = liftIO $ getObjectPropertyString obj "im-module"++setEntryImModule :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryImModule obj val = liftIO $ setObjectPropertyString obj "im-module" val++constructEntryImModule :: T.Text -> IO ([Char], GValue)+constructEntryImModule val = constructObjectPropertyString "im-module" val++data EntryImModulePropertyInfo+instance AttrInfo EntryImModulePropertyInfo where+    type AttrAllowedOps EntryImModulePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryImModulePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryImModulePropertyInfo = EntryK+    type AttrGetType EntryImModulePropertyInfo = T.Text+    type AttrLabel EntryImModulePropertyInfo = "Entry::im-module"+    attrGet _ = getEntryImModule+    attrSet _ = setEntryImModule+    attrConstruct _ = constructEntryImModule++-- VVV Prop "inner-border"+   -- Type: TInterface "Gtk" "Border"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryInnerBorder :: (MonadIO m, EntryK o) => o -> m Border+getEntryInnerBorder obj = liftIO $ getObjectPropertyBoxed obj "inner-border" Border++setEntryInnerBorder :: (MonadIO m, EntryK o) => o -> Border -> m ()+setEntryInnerBorder obj val = liftIO $ setObjectPropertyBoxed obj "inner-border" val++constructEntryInnerBorder :: Border -> IO ([Char], GValue)+constructEntryInnerBorder val = constructObjectPropertyBoxed "inner-border" val++data EntryInnerBorderPropertyInfo+instance AttrInfo EntryInnerBorderPropertyInfo where+    type AttrAllowedOps EntryInnerBorderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryInnerBorderPropertyInfo = (~) Border+    type AttrBaseTypeConstraint EntryInnerBorderPropertyInfo = EntryK+    type AttrGetType EntryInnerBorderPropertyInfo = Border+    type AttrLabel EntryInnerBorderPropertyInfo = "Entry::inner-border"+    attrGet _ = getEntryInnerBorder+    attrSet _ = setEntryInnerBorder+    attrConstruct _ = constructEntryInnerBorder++-- VVV Prop "input-hints"+   -- Type: TInterface "Gtk" "InputHints"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryInputHints :: (MonadIO m, EntryK o) => o -> m [InputHints]+getEntryInputHints obj = liftIO $ getObjectPropertyFlags obj "input-hints"++setEntryInputHints :: (MonadIO m, EntryK o) => o -> [InputHints] -> m ()+setEntryInputHints obj val = liftIO $ setObjectPropertyFlags obj "input-hints" val++constructEntryInputHints :: [InputHints] -> IO ([Char], GValue)+constructEntryInputHints val = constructObjectPropertyFlags "input-hints" val++data EntryInputHintsPropertyInfo+instance AttrInfo EntryInputHintsPropertyInfo where+    type AttrAllowedOps EntryInputHintsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryInputHintsPropertyInfo = (~) [InputHints]+    type AttrBaseTypeConstraint EntryInputHintsPropertyInfo = EntryK+    type AttrGetType EntryInputHintsPropertyInfo = [InputHints]+    type AttrLabel EntryInputHintsPropertyInfo = "Entry::input-hints"+    attrGet _ = getEntryInputHints+    attrSet _ = setEntryInputHints+    attrConstruct _ = constructEntryInputHints++-- VVV Prop "input-purpose"+   -- Type: TInterface "Gtk" "InputPurpose"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryInputPurpose :: (MonadIO m, EntryK o) => o -> m InputPurpose+getEntryInputPurpose obj = liftIO $ getObjectPropertyEnum obj "input-purpose"++setEntryInputPurpose :: (MonadIO m, EntryK o) => o -> InputPurpose -> m ()+setEntryInputPurpose obj val = liftIO $ setObjectPropertyEnum obj "input-purpose" val++constructEntryInputPurpose :: InputPurpose -> IO ([Char], GValue)+constructEntryInputPurpose val = constructObjectPropertyEnum "input-purpose" val++data EntryInputPurposePropertyInfo+instance AttrInfo EntryInputPurposePropertyInfo where+    type AttrAllowedOps EntryInputPurposePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryInputPurposePropertyInfo = (~) InputPurpose+    type AttrBaseTypeConstraint EntryInputPurposePropertyInfo = EntryK+    type AttrGetType EntryInputPurposePropertyInfo = InputPurpose+    type AttrLabel EntryInputPurposePropertyInfo = "Entry::input-purpose"+    attrGet _ = getEntryInputPurpose+    attrSet _ = setEntryInputPurpose+    attrConstruct _ = constructEntryInputPurpose++-- VVV Prop "invisible-char"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryInvisibleChar :: (MonadIO m, EntryK o) => o -> m Word32+getEntryInvisibleChar obj = liftIO $ getObjectPropertyCUInt obj "invisible-char"++setEntryInvisibleChar :: (MonadIO m, EntryK o) => o -> Word32 -> m ()+setEntryInvisibleChar obj val = liftIO $ setObjectPropertyCUInt obj "invisible-char" val++constructEntryInvisibleChar :: Word32 -> IO ([Char], GValue)+constructEntryInvisibleChar val = constructObjectPropertyCUInt "invisible-char" val++data EntryInvisibleCharPropertyInfo+instance AttrInfo EntryInvisibleCharPropertyInfo where+    type AttrAllowedOps EntryInvisibleCharPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryInvisibleCharPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint EntryInvisibleCharPropertyInfo = EntryK+    type AttrGetType EntryInvisibleCharPropertyInfo = Word32+    type AttrLabel EntryInvisibleCharPropertyInfo = "Entry::invisible-char"+    attrGet _ = getEntryInvisibleChar+    attrSet _ = setEntryInvisibleChar+    attrConstruct _ = constructEntryInvisibleChar++-- VVV Prop "invisible-char-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryInvisibleCharSet :: (MonadIO m, EntryK o) => o -> m Bool+getEntryInvisibleCharSet obj = liftIO $ getObjectPropertyBool obj "invisible-char-set"++setEntryInvisibleCharSet :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryInvisibleCharSet obj val = liftIO $ setObjectPropertyBool obj "invisible-char-set" val++constructEntryInvisibleCharSet :: Bool -> IO ([Char], GValue)+constructEntryInvisibleCharSet val = constructObjectPropertyBool "invisible-char-set" val++data EntryInvisibleCharSetPropertyInfo+instance AttrInfo EntryInvisibleCharSetPropertyInfo where+    type AttrAllowedOps EntryInvisibleCharSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryInvisibleCharSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryInvisibleCharSetPropertyInfo = EntryK+    type AttrGetType EntryInvisibleCharSetPropertyInfo = Bool+    type AttrLabel EntryInvisibleCharSetPropertyInfo = "Entry::invisible-char-set"+    attrGet _ = getEntryInvisibleCharSet+    attrSet _ = setEntryInvisibleCharSet+    attrConstruct _ = constructEntryInvisibleCharSet++-- VVV Prop "max-length"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryMaxLength :: (MonadIO m, EntryK o) => o -> m Int32+getEntryMaxLength obj = liftIO $ getObjectPropertyCInt obj "max-length"++setEntryMaxLength :: (MonadIO m, EntryK o) => o -> Int32 -> m ()+setEntryMaxLength obj val = liftIO $ setObjectPropertyCInt obj "max-length" val++constructEntryMaxLength :: Int32 -> IO ([Char], GValue)+constructEntryMaxLength val = constructObjectPropertyCInt "max-length" val++data EntryMaxLengthPropertyInfo+instance AttrInfo EntryMaxLengthPropertyInfo where+    type AttrAllowedOps EntryMaxLengthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryMaxLengthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryMaxLengthPropertyInfo = EntryK+    type AttrGetType EntryMaxLengthPropertyInfo = Int32+    type AttrLabel EntryMaxLengthPropertyInfo = "Entry::max-length"+    attrGet _ = getEntryMaxLength+    attrSet _ = setEntryMaxLength+    attrConstruct _ = constructEntryMaxLength++-- VVV Prop "max-width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryMaxWidthChars :: (MonadIO m, EntryK o) => o -> m Int32+getEntryMaxWidthChars obj = liftIO $ getObjectPropertyCInt obj "max-width-chars"++setEntryMaxWidthChars :: (MonadIO m, EntryK o) => o -> Int32 -> m ()+setEntryMaxWidthChars obj val = liftIO $ setObjectPropertyCInt obj "max-width-chars" val++constructEntryMaxWidthChars :: Int32 -> IO ([Char], GValue)+constructEntryMaxWidthChars val = constructObjectPropertyCInt "max-width-chars" val++data EntryMaxWidthCharsPropertyInfo+instance AttrInfo EntryMaxWidthCharsPropertyInfo where+    type AttrAllowedOps EntryMaxWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryMaxWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryMaxWidthCharsPropertyInfo = EntryK+    type AttrGetType EntryMaxWidthCharsPropertyInfo = Int32+    type AttrLabel EntryMaxWidthCharsPropertyInfo = "Entry::max-width-chars"+    attrGet _ = getEntryMaxWidthChars+    attrSet _ = setEntryMaxWidthChars+    attrConstruct _ = constructEntryMaxWidthChars++-- VVV Prop "overwrite-mode"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryOverwriteMode :: (MonadIO m, EntryK o) => o -> m Bool+getEntryOverwriteMode obj = liftIO $ getObjectPropertyBool obj "overwrite-mode"++setEntryOverwriteMode :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryOverwriteMode obj val = liftIO $ setObjectPropertyBool obj "overwrite-mode" val++constructEntryOverwriteMode :: Bool -> IO ([Char], GValue)+constructEntryOverwriteMode val = constructObjectPropertyBool "overwrite-mode" val++data EntryOverwriteModePropertyInfo+instance AttrInfo EntryOverwriteModePropertyInfo where+    type AttrAllowedOps EntryOverwriteModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryOverwriteModePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryOverwriteModePropertyInfo = EntryK+    type AttrGetType EntryOverwriteModePropertyInfo = Bool+    type AttrLabel EntryOverwriteModePropertyInfo = "Entry::overwrite-mode"+    attrGet _ = getEntryOverwriteMode+    attrSet _ = setEntryOverwriteMode+    attrConstruct _ = constructEntryOverwriteMode++-- VVV Prop "placeholder-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPlaceholderText :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryPlaceholderText obj = liftIO $ getObjectPropertyString obj "placeholder-text"++setEntryPlaceholderText :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryPlaceholderText obj val = liftIO $ setObjectPropertyString obj "placeholder-text" val++constructEntryPlaceholderText :: T.Text -> IO ([Char], GValue)+constructEntryPlaceholderText val = constructObjectPropertyString "placeholder-text" val++data EntryPlaceholderTextPropertyInfo+instance AttrInfo EntryPlaceholderTextPropertyInfo where+    type AttrAllowedOps EntryPlaceholderTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPlaceholderTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryPlaceholderTextPropertyInfo = EntryK+    type AttrGetType EntryPlaceholderTextPropertyInfo = T.Text+    type AttrLabel EntryPlaceholderTextPropertyInfo = "Entry::placeholder-text"+    attrGet _ = getEntryPlaceholderText+    attrSet _ = setEntryPlaceholderText+    attrConstruct _ = constructEntryPlaceholderText++-- VVV Prop "populate-all"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPopulateAll :: (MonadIO m, EntryK o) => o -> m Bool+getEntryPopulateAll obj = liftIO $ getObjectPropertyBool obj "populate-all"++setEntryPopulateAll :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryPopulateAll obj val = liftIO $ setObjectPropertyBool obj "populate-all" val++constructEntryPopulateAll :: Bool -> IO ([Char], GValue)+constructEntryPopulateAll val = constructObjectPropertyBool "populate-all" val++data EntryPopulateAllPropertyInfo+instance AttrInfo EntryPopulateAllPropertyInfo where+    type AttrAllowedOps EntryPopulateAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPopulateAllPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryPopulateAllPropertyInfo = EntryK+    type AttrGetType EntryPopulateAllPropertyInfo = Bool+    type AttrLabel EntryPopulateAllPropertyInfo = "Entry::populate-all"+    attrGet _ = getEntryPopulateAll+    attrSet _ = setEntryPopulateAll+    attrConstruct _ = constructEntryPopulateAll++-- VVV Prop "primary-icon-activatable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconActivatable :: (MonadIO m, EntryK o) => o -> m Bool+getEntryPrimaryIconActivatable obj = liftIO $ getObjectPropertyBool obj "primary-icon-activatable"++setEntryPrimaryIconActivatable :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryPrimaryIconActivatable obj val = liftIO $ setObjectPropertyBool obj "primary-icon-activatable" val++constructEntryPrimaryIconActivatable :: Bool -> IO ([Char], GValue)+constructEntryPrimaryIconActivatable val = constructObjectPropertyBool "primary-icon-activatable" val++data EntryPrimaryIconActivatablePropertyInfo+instance AttrInfo EntryPrimaryIconActivatablePropertyInfo where+    type AttrAllowedOps EntryPrimaryIconActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconActivatablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryPrimaryIconActivatablePropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconActivatablePropertyInfo = Bool+    type AttrLabel EntryPrimaryIconActivatablePropertyInfo = "Entry::primary-icon-activatable"+    attrGet _ = getEntryPrimaryIconActivatable+    attrSet _ = setEntryPrimaryIconActivatable+    attrConstruct _ = constructEntryPrimaryIconActivatable++-- VVV Prop "primary-icon-gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconGicon :: (MonadIO m, EntryK o) => o -> m Gio.Icon+getEntryPrimaryIconGicon obj = liftIO $ getObjectPropertyObject obj "primary-icon-gicon" Gio.Icon++setEntryPrimaryIconGicon :: (MonadIO m, EntryK o, Gio.IconK a) => o -> a -> m ()+setEntryPrimaryIconGicon obj val = liftIO $ setObjectPropertyObject obj "primary-icon-gicon" val++constructEntryPrimaryIconGicon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructEntryPrimaryIconGicon val = constructObjectPropertyObject "primary-icon-gicon" val++data EntryPrimaryIconGiconPropertyInfo+instance AttrInfo EntryPrimaryIconGiconPropertyInfo where+    type AttrAllowedOps EntryPrimaryIconGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconGiconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint EntryPrimaryIconGiconPropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconGiconPropertyInfo = Gio.Icon+    type AttrLabel EntryPrimaryIconGiconPropertyInfo = "Entry::primary-icon-gicon"+    attrGet _ = getEntryPrimaryIconGicon+    attrSet _ = setEntryPrimaryIconGicon+    attrConstruct _ = constructEntryPrimaryIconGicon++-- VVV Prop "primary-icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconName :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryPrimaryIconName obj = liftIO $ getObjectPropertyString obj "primary-icon-name"++setEntryPrimaryIconName :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryPrimaryIconName obj val = liftIO $ setObjectPropertyString obj "primary-icon-name" val++constructEntryPrimaryIconName :: T.Text -> IO ([Char], GValue)+constructEntryPrimaryIconName val = constructObjectPropertyString "primary-icon-name" val++data EntryPrimaryIconNamePropertyInfo+instance AttrInfo EntryPrimaryIconNamePropertyInfo where+    type AttrAllowedOps EntryPrimaryIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryPrimaryIconNamePropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconNamePropertyInfo = T.Text+    type AttrLabel EntryPrimaryIconNamePropertyInfo = "Entry::primary-icon-name"+    attrGet _ = getEntryPrimaryIconName+    attrSet _ = setEntryPrimaryIconName+    attrConstruct _ = constructEntryPrimaryIconName++-- VVV Prop "primary-icon-pixbuf"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconPixbuf :: (MonadIO m, EntryK o) => o -> m GdkPixbuf.Pixbuf+getEntryPrimaryIconPixbuf obj = liftIO $ getObjectPropertyObject obj "primary-icon-pixbuf" GdkPixbuf.Pixbuf++setEntryPrimaryIconPixbuf :: (MonadIO m, EntryK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setEntryPrimaryIconPixbuf obj val = liftIO $ setObjectPropertyObject obj "primary-icon-pixbuf" val++constructEntryPrimaryIconPixbuf :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructEntryPrimaryIconPixbuf val = constructObjectPropertyObject "primary-icon-pixbuf" val++data EntryPrimaryIconPixbufPropertyInfo+instance AttrInfo EntryPrimaryIconPixbufPropertyInfo where+    type AttrAllowedOps EntryPrimaryIconPixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconPixbufPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint EntryPrimaryIconPixbufPropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconPixbufPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel EntryPrimaryIconPixbufPropertyInfo = "Entry::primary-icon-pixbuf"+    attrGet _ = getEntryPrimaryIconPixbuf+    attrSet _ = setEntryPrimaryIconPixbuf+    attrConstruct _ = constructEntryPrimaryIconPixbuf++-- VVV Prop "primary-icon-sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconSensitive :: (MonadIO m, EntryK o) => o -> m Bool+getEntryPrimaryIconSensitive obj = liftIO $ getObjectPropertyBool obj "primary-icon-sensitive"++setEntryPrimaryIconSensitive :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryPrimaryIconSensitive obj val = liftIO $ setObjectPropertyBool obj "primary-icon-sensitive" val++constructEntryPrimaryIconSensitive :: Bool -> IO ([Char], GValue)+constructEntryPrimaryIconSensitive val = constructObjectPropertyBool "primary-icon-sensitive" val++data EntryPrimaryIconSensitivePropertyInfo+instance AttrInfo EntryPrimaryIconSensitivePropertyInfo where+    type AttrAllowedOps EntryPrimaryIconSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryPrimaryIconSensitivePropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconSensitivePropertyInfo = Bool+    type AttrLabel EntryPrimaryIconSensitivePropertyInfo = "Entry::primary-icon-sensitive"+    attrGet _ = getEntryPrimaryIconSensitive+    attrSet _ = setEntryPrimaryIconSensitive+    attrConstruct _ = constructEntryPrimaryIconSensitive++-- VVV Prop "primary-icon-stock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconStock :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryPrimaryIconStock obj = liftIO $ getObjectPropertyString obj "primary-icon-stock"++setEntryPrimaryIconStock :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryPrimaryIconStock obj val = liftIO $ setObjectPropertyString obj "primary-icon-stock" val++constructEntryPrimaryIconStock :: T.Text -> IO ([Char], GValue)+constructEntryPrimaryIconStock val = constructObjectPropertyString "primary-icon-stock" val++data EntryPrimaryIconStockPropertyInfo+instance AttrInfo EntryPrimaryIconStockPropertyInfo where+    type AttrAllowedOps EntryPrimaryIconStockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconStockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryPrimaryIconStockPropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconStockPropertyInfo = T.Text+    type AttrLabel EntryPrimaryIconStockPropertyInfo = "Entry::primary-icon-stock"+    attrGet _ = getEntryPrimaryIconStock+    attrSet _ = setEntryPrimaryIconStock+    attrConstruct _ = constructEntryPrimaryIconStock++-- VVV Prop "primary-icon-storage-type"+   -- Type: TInterface "Gtk" "ImageType"+   -- Flags: [PropertyReadable]++getEntryPrimaryIconStorageType :: (MonadIO m, EntryK o) => o -> m ImageType+getEntryPrimaryIconStorageType obj = liftIO $ getObjectPropertyEnum obj "primary-icon-storage-type"++data EntryPrimaryIconStorageTypePropertyInfo+instance AttrInfo EntryPrimaryIconStorageTypePropertyInfo where+    type AttrAllowedOps EntryPrimaryIconStorageTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconStorageTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntryPrimaryIconStorageTypePropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconStorageTypePropertyInfo = ImageType+    type AttrLabel EntryPrimaryIconStorageTypePropertyInfo = "Entry::primary-icon-storage-type"+    attrGet _ = getEntryPrimaryIconStorageType+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "primary-icon-tooltip-markup"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconTooltipMarkup :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryPrimaryIconTooltipMarkup obj = liftIO $ getObjectPropertyString obj "primary-icon-tooltip-markup"++setEntryPrimaryIconTooltipMarkup :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryPrimaryIconTooltipMarkup obj val = liftIO $ setObjectPropertyString obj "primary-icon-tooltip-markup" val++constructEntryPrimaryIconTooltipMarkup :: T.Text -> IO ([Char], GValue)+constructEntryPrimaryIconTooltipMarkup val = constructObjectPropertyString "primary-icon-tooltip-markup" val++data EntryPrimaryIconTooltipMarkupPropertyInfo+instance AttrInfo EntryPrimaryIconTooltipMarkupPropertyInfo where+    type AttrAllowedOps EntryPrimaryIconTooltipMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconTooltipMarkupPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryPrimaryIconTooltipMarkupPropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconTooltipMarkupPropertyInfo = T.Text+    type AttrLabel EntryPrimaryIconTooltipMarkupPropertyInfo = "Entry::primary-icon-tooltip-markup"+    attrGet _ = getEntryPrimaryIconTooltipMarkup+    attrSet _ = setEntryPrimaryIconTooltipMarkup+    attrConstruct _ = constructEntryPrimaryIconTooltipMarkup++-- VVV Prop "primary-icon-tooltip-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryPrimaryIconTooltipText :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryPrimaryIconTooltipText obj = liftIO $ getObjectPropertyString obj "primary-icon-tooltip-text"++setEntryPrimaryIconTooltipText :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryPrimaryIconTooltipText obj val = liftIO $ setObjectPropertyString obj "primary-icon-tooltip-text" val++constructEntryPrimaryIconTooltipText :: T.Text -> IO ([Char], GValue)+constructEntryPrimaryIconTooltipText val = constructObjectPropertyString "primary-icon-tooltip-text" val++data EntryPrimaryIconTooltipTextPropertyInfo+instance AttrInfo EntryPrimaryIconTooltipTextPropertyInfo where+    type AttrAllowedOps EntryPrimaryIconTooltipTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryPrimaryIconTooltipTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryPrimaryIconTooltipTextPropertyInfo = EntryK+    type AttrGetType EntryPrimaryIconTooltipTextPropertyInfo = T.Text+    type AttrLabel EntryPrimaryIconTooltipTextPropertyInfo = "Entry::primary-icon-tooltip-text"+    attrGet _ = getEntryPrimaryIconTooltipText+    attrSet _ = setEntryPrimaryIconTooltipText+    attrConstruct _ = constructEntryPrimaryIconTooltipText++-- VVV Prop "progress-fraction"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryProgressFraction :: (MonadIO m, EntryK o) => o -> m Double+getEntryProgressFraction obj = liftIO $ getObjectPropertyDouble obj "progress-fraction"++setEntryProgressFraction :: (MonadIO m, EntryK o) => o -> Double -> m ()+setEntryProgressFraction obj val = liftIO $ setObjectPropertyDouble obj "progress-fraction" val++constructEntryProgressFraction :: Double -> IO ([Char], GValue)+constructEntryProgressFraction val = constructObjectPropertyDouble "progress-fraction" val++data EntryProgressFractionPropertyInfo+instance AttrInfo EntryProgressFractionPropertyInfo where+    type AttrAllowedOps EntryProgressFractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryProgressFractionPropertyInfo = (~) Double+    type AttrBaseTypeConstraint EntryProgressFractionPropertyInfo = EntryK+    type AttrGetType EntryProgressFractionPropertyInfo = Double+    type AttrLabel EntryProgressFractionPropertyInfo = "Entry::progress-fraction"+    attrGet _ = getEntryProgressFraction+    attrSet _ = setEntryProgressFraction+    attrConstruct _ = constructEntryProgressFraction++-- VVV Prop "progress-pulse-step"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryProgressPulseStep :: (MonadIO m, EntryK o) => o -> m Double+getEntryProgressPulseStep obj = liftIO $ getObjectPropertyDouble obj "progress-pulse-step"++setEntryProgressPulseStep :: (MonadIO m, EntryK o) => o -> Double -> m ()+setEntryProgressPulseStep obj val = liftIO $ setObjectPropertyDouble obj "progress-pulse-step" val++constructEntryProgressPulseStep :: Double -> IO ([Char], GValue)+constructEntryProgressPulseStep val = constructObjectPropertyDouble "progress-pulse-step" val++data EntryProgressPulseStepPropertyInfo+instance AttrInfo EntryProgressPulseStepPropertyInfo where+    type AttrAllowedOps EntryProgressPulseStepPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryProgressPulseStepPropertyInfo = (~) Double+    type AttrBaseTypeConstraint EntryProgressPulseStepPropertyInfo = EntryK+    type AttrGetType EntryProgressPulseStepPropertyInfo = Double+    type AttrLabel EntryProgressPulseStepPropertyInfo = "Entry::progress-pulse-step"+    attrGet _ = getEntryProgressPulseStep+    attrSet _ = setEntryProgressPulseStep+    attrConstruct _ = constructEntryProgressPulseStep++-- VVV Prop "scroll-offset"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getEntryScrollOffset :: (MonadIO m, EntryK o) => o -> m Int32+getEntryScrollOffset obj = liftIO $ getObjectPropertyCInt obj "scroll-offset"++data EntryScrollOffsetPropertyInfo+instance AttrInfo EntryScrollOffsetPropertyInfo where+    type AttrAllowedOps EntryScrollOffsetPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntryScrollOffsetPropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntryScrollOffsetPropertyInfo = EntryK+    type AttrGetType EntryScrollOffsetPropertyInfo = Int32+    type AttrLabel EntryScrollOffsetPropertyInfo = "Entry::scroll-offset"+    attrGet _ = getEntryScrollOffset+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "secondary-icon-activatable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconActivatable :: (MonadIO m, EntryK o) => o -> m Bool+getEntrySecondaryIconActivatable obj = liftIO $ getObjectPropertyBool obj "secondary-icon-activatable"++setEntrySecondaryIconActivatable :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntrySecondaryIconActivatable obj val = liftIO $ setObjectPropertyBool obj "secondary-icon-activatable" val++constructEntrySecondaryIconActivatable :: Bool -> IO ([Char], GValue)+constructEntrySecondaryIconActivatable val = constructObjectPropertyBool "secondary-icon-activatable" val++data EntrySecondaryIconActivatablePropertyInfo+instance AttrInfo EntrySecondaryIconActivatablePropertyInfo where+    type AttrAllowedOps EntrySecondaryIconActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconActivatablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntrySecondaryIconActivatablePropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconActivatablePropertyInfo = Bool+    type AttrLabel EntrySecondaryIconActivatablePropertyInfo = "Entry::secondary-icon-activatable"+    attrGet _ = getEntrySecondaryIconActivatable+    attrSet _ = setEntrySecondaryIconActivatable+    attrConstruct _ = constructEntrySecondaryIconActivatable++-- VVV Prop "secondary-icon-gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconGicon :: (MonadIO m, EntryK o) => o -> m Gio.Icon+getEntrySecondaryIconGicon obj = liftIO $ getObjectPropertyObject obj "secondary-icon-gicon" Gio.Icon++setEntrySecondaryIconGicon :: (MonadIO m, EntryK o, Gio.IconK a) => o -> a -> m ()+setEntrySecondaryIconGicon obj val = liftIO $ setObjectPropertyObject obj "secondary-icon-gicon" val++constructEntrySecondaryIconGicon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructEntrySecondaryIconGicon val = constructObjectPropertyObject "secondary-icon-gicon" val++data EntrySecondaryIconGiconPropertyInfo+instance AttrInfo EntrySecondaryIconGiconPropertyInfo where+    type AttrAllowedOps EntrySecondaryIconGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconGiconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint EntrySecondaryIconGiconPropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconGiconPropertyInfo = Gio.Icon+    type AttrLabel EntrySecondaryIconGiconPropertyInfo = "Entry::secondary-icon-gicon"+    attrGet _ = getEntrySecondaryIconGicon+    attrSet _ = setEntrySecondaryIconGicon+    attrConstruct _ = constructEntrySecondaryIconGicon++-- VVV Prop "secondary-icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconName :: (MonadIO m, EntryK o) => o -> m T.Text+getEntrySecondaryIconName obj = liftIO $ getObjectPropertyString obj "secondary-icon-name"++setEntrySecondaryIconName :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntrySecondaryIconName obj val = liftIO $ setObjectPropertyString obj "secondary-icon-name" val++constructEntrySecondaryIconName :: T.Text -> IO ([Char], GValue)+constructEntrySecondaryIconName val = constructObjectPropertyString "secondary-icon-name" val++data EntrySecondaryIconNamePropertyInfo+instance AttrInfo EntrySecondaryIconNamePropertyInfo where+    type AttrAllowedOps EntrySecondaryIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntrySecondaryIconNamePropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconNamePropertyInfo = T.Text+    type AttrLabel EntrySecondaryIconNamePropertyInfo = "Entry::secondary-icon-name"+    attrGet _ = getEntrySecondaryIconName+    attrSet _ = setEntrySecondaryIconName+    attrConstruct _ = constructEntrySecondaryIconName++-- VVV Prop "secondary-icon-pixbuf"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconPixbuf :: (MonadIO m, EntryK o) => o -> m GdkPixbuf.Pixbuf+getEntrySecondaryIconPixbuf obj = liftIO $ getObjectPropertyObject obj "secondary-icon-pixbuf" GdkPixbuf.Pixbuf++setEntrySecondaryIconPixbuf :: (MonadIO m, EntryK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setEntrySecondaryIconPixbuf obj val = liftIO $ setObjectPropertyObject obj "secondary-icon-pixbuf" val++constructEntrySecondaryIconPixbuf :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructEntrySecondaryIconPixbuf val = constructObjectPropertyObject "secondary-icon-pixbuf" val++data EntrySecondaryIconPixbufPropertyInfo+instance AttrInfo EntrySecondaryIconPixbufPropertyInfo where+    type AttrAllowedOps EntrySecondaryIconPixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconPixbufPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint EntrySecondaryIconPixbufPropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconPixbufPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel EntrySecondaryIconPixbufPropertyInfo = "Entry::secondary-icon-pixbuf"+    attrGet _ = getEntrySecondaryIconPixbuf+    attrSet _ = setEntrySecondaryIconPixbuf+    attrConstruct _ = constructEntrySecondaryIconPixbuf++-- VVV Prop "secondary-icon-sensitive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconSensitive :: (MonadIO m, EntryK o) => o -> m Bool+getEntrySecondaryIconSensitive obj = liftIO $ getObjectPropertyBool obj "secondary-icon-sensitive"++setEntrySecondaryIconSensitive :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntrySecondaryIconSensitive obj val = liftIO $ setObjectPropertyBool obj "secondary-icon-sensitive" val++constructEntrySecondaryIconSensitive :: Bool -> IO ([Char], GValue)+constructEntrySecondaryIconSensitive val = constructObjectPropertyBool "secondary-icon-sensitive" val++data EntrySecondaryIconSensitivePropertyInfo+instance AttrInfo EntrySecondaryIconSensitivePropertyInfo where+    type AttrAllowedOps EntrySecondaryIconSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconSensitivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntrySecondaryIconSensitivePropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconSensitivePropertyInfo = Bool+    type AttrLabel EntrySecondaryIconSensitivePropertyInfo = "Entry::secondary-icon-sensitive"+    attrGet _ = getEntrySecondaryIconSensitive+    attrSet _ = setEntrySecondaryIconSensitive+    attrConstruct _ = constructEntrySecondaryIconSensitive++-- VVV Prop "secondary-icon-stock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconStock :: (MonadIO m, EntryK o) => o -> m T.Text+getEntrySecondaryIconStock obj = liftIO $ getObjectPropertyString obj "secondary-icon-stock"++setEntrySecondaryIconStock :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntrySecondaryIconStock obj val = liftIO $ setObjectPropertyString obj "secondary-icon-stock" val++constructEntrySecondaryIconStock :: T.Text -> IO ([Char], GValue)+constructEntrySecondaryIconStock val = constructObjectPropertyString "secondary-icon-stock" val++data EntrySecondaryIconStockPropertyInfo+instance AttrInfo EntrySecondaryIconStockPropertyInfo where+    type AttrAllowedOps EntrySecondaryIconStockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconStockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntrySecondaryIconStockPropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconStockPropertyInfo = T.Text+    type AttrLabel EntrySecondaryIconStockPropertyInfo = "Entry::secondary-icon-stock"+    attrGet _ = getEntrySecondaryIconStock+    attrSet _ = setEntrySecondaryIconStock+    attrConstruct _ = constructEntrySecondaryIconStock++-- VVV Prop "secondary-icon-storage-type"+   -- Type: TInterface "Gtk" "ImageType"+   -- Flags: [PropertyReadable]++getEntrySecondaryIconStorageType :: (MonadIO m, EntryK o) => o -> m ImageType+getEntrySecondaryIconStorageType obj = liftIO $ getObjectPropertyEnum obj "secondary-icon-storage-type"++data EntrySecondaryIconStorageTypePropertyInfo+instance AttrInfo EntrySecondaryIconStorageTypePropertyInfo where+    type AttrAllowedOps EntrySecondaryIconStorageTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconStorageTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntrySecondaryIconStorageTypePropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconStorageTypePropertyInfo = ImageType+    type AttrLabel EntrySecondaryIconStorageTypePropertyInfo = "Entry::secondary-icon-storage-type"+    attrGet _ = getEntrySecondaryIconStorageType+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "secondary-icon-tooltip-markup"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconTooltipMarkup :: (MonadIO m, EntryK o) => o -> m T.Text+getEntrySecondaryIconTooltipMarkup obj = liftIO $ getObjectPropertyString obj "secondary-icon-tooltip-markup"++setEntrySecondaryIconTooltipMarkup :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntrySecondaryIconTooltipMarkup obj val = liftIO $ setObjectPropertyString obj "secondary-icon-tooltip-markup" val++constructEntrySecondaryIconTooltipMarkup :: T.Text -> IO ([Char], GValue)+constructEntrySecondaryIconTooltipMarkup val = constructObjectPropertyString "secondary-icon-tooltip-markup" val++data EntrySecondaryIconTooltipMarkupPropertyInfo+instance AttrInfo EntrySecondaryIconTooltipMarkupPropertyInfo where+    type AttrAllowedOps EntrySecondaryIconTooltipMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconTooltipMarkupPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntrySecondaryIconTooltipMarkupPropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconTooltipMarkupPropertyInfo = T.Text+    type AttrLabel EntrySecondaryIconTooltipMarkupPropertyInfo = "Entry::secondary-icon-tooltip-markup"+    attrGet _ = getEntrySecondaryIconTooltipMarkup+    attrSet _ = setEntrySecondaryIconTooltipMarkup+    attrConstruct _ = constructEntrySecondaryIconTooltipMarkup++-- VVV Prop "secondary-icon-tooltip-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntrySecondaryIconTooltipText :: (MonadIO m, EntryK o) => o -> m T.Text+getEntrySecondaryIconTooltipText obj = liftIO $ getObjectPropertyString obj "secondary-icon-tooltip-text"++setEntrySecondaryIconTooltipText :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntrySecondaryIconTooltipText obj val = liftIO $ setObjectPropertyString obj "secondary-icon-tooltip-text" val++constructEntrySecondaryIconTooltipText :: T.Text -> IO ([Char], GValue)+constructEntrySecondaryIconTooltipText val = constructObjectPropertyString "secondary-icon-tooltip-text" val++data EntrySecondaryIconTooltipTextPropertyInfo+instance AttrInfo EntrySecondaryIconTooltipTextPropertyInfo where+    type AttrAllowedOps EntrySecondaryIconTooltipTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntrySecondaryIconTooltipTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntrySecondaryIconTooltipTextPropertyInfo = EntryK+    type AttrGetType EntrySecondaryIconTooltipTextPropertyInfo = T.Text+    type AttrLabel EntrySecondaryIconTooltipTextPropertyInfo = "Entry::secondary-icon-tooltip-text"+    attrGet _ = getEntrySecondaryIconTooltipText+    attrSet _ = setEntrySecondaryIconTooltipText+    attrConstruct _ = constructEntrySecondaryIconTooltipText++-- VVV Prop "selection-bound"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getEntrySelectionBound :: (MonadIO m, EntryK o) => o -> m Int32+getEntrySelectionBound obj = liftIO $ getObjectPropertyCInt obj "selection-bound"++data EntrySelectionBoundPropertyInfo+instance AttrInfo EntrySelectionBoundPropertyInfo where+    type AttrAllowedOps EntrySelectionBoundPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntrySelectionBoundPropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntrySelectionBoundPropertyInfo = EntryK+    type AttrGetType EntrySelectionBoundPropertyInfo = Int32+    type AttrLabel EntrySelectionBoundPropertyInfo = "Entry::selection-bound"+    attrGet _ = getEntrySelectionBound+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "shadow-type"+   -- Type: TInterface "Gtk" "ShadowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryShadowType :: (MonadIO m, EntryK o) => o -> m ShadowType+getEntryShadowType obj = liftIO $ getObjectPropertyEnum obj "shadow-type"++setEntryShadowType :: (MonadIO m, EntryK o) => o -> ShadowType -> m ()+setEntryShadowType obj val = liftIO $ setObjectPropertyEnum obj "shadow-type" val++constructEntryShadowType :: ShadowType -> IO ([Char], GValue)+constructEntryShadowType val = constructObjectPropertyEnum "shadow-type" val++data EntryShadowTypePropertyInfo+instance AttrInfo EntryShadowTypePropertyInfo where+    type AttrAllowedOps EntryShadowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryShadowTypePropertyInfo = (~) ShadowType+    type AttrBaseTypeConstraint EntryShadowTypePropertyInfo = EntryK+    type AttrGetType EntryShadowTypePropertyInfo = ShadowType+    type AttrLabel EntryShadowTypePropertyInfo = "Entry::shadow-type"+    attrGet _ = getEntryShadowType+    attrSet _ = setEntryShadowType+    attrConstruct _ = constructEntryShadowType++-- VVV Prop "tabs"+   -- Type: TInterface "Pango" "TabArray"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryTabs :: (MonadIO m, EntryK o) => o -> m Pango.TabArray+getEntryTabs obj = liftIO $ getObjectPropertyBoxed obj "tabs" Pango.TabArray++setEntryTabs :: (MonadIO m, EntryK o) => o -> Pango.TabArray -> m ()+setEntryTabs obj val = liftIO $ setObjectPropertyBoxed obj "tabs" val++constructEntryTabs :: Pango.TabArray -> IO ([Char], GValue)+constructEntryTabs val = constructObjectPropertyBoxed "tabs" val++data EntryTabsPropertyInfo+instance AttrInfo EntryTabsPropertyInfo where+    type AttrAllowedOps EntryTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryTabsPropertyInfo = (~) Pango.TabArray+    type AttrBaseTypeConstraint EntryTabsPropertyInfo = EntryK+    type AttrGetType EntryTabsPropertyInfo = Pango.TabArray+    type AttrLabel EntryTabsPropertyInfo = "Entry::tabs"+    attrGet _ = getEntryTabs+    attrSet _ = setEntryTabs+    attrConstruct _ = constructEntryTabs++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryText :: (MonadIO m, EntryK o) => o -> m T.Text+getEntryText obj = liftIO $ getObjectPropertyString obj "text"++setEntryText :: (MonadIO m, EntryK o) => o -> T.Text -> m ()+setEntryText obj val = liftIO $ setObjectPropertyString obj "text" val++constructEntryText :: T.Text -> IO ([Char], GValue)+constructEntryText val = constructObjectPropertyString "text" val++data EntryTextPropertyInfo+instance AttrInfo EntryTextPropertyInfo where+    type AttrAllowedOps EntryTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryTextPropertyInfo = EntryK+    type AttrGetType EntryTextPropertyInfo = T.Text+    type AttrLabel EntryTextPropertyInfo = "Entry::text"+    attrGet _ = getEntryText+    attrSet _ = setEntryText+    attrConstruct _ = constructEntryText++-- VVV Prop "text-length"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable]++getEntryTextLength :: (MonadIO m, EntryK o) => o -> m Word32+getEntryTextLength obj = liftIO $ getObjectPropertyCUInt obj "text-length"++data EntryTextLengthPropertyInfo+instance AttrInfo EntryTextLengthPropertyInfo where+    type AttrAllowedOps EntryTextLengthPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntryTextLengthPropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntryTextLengthPropertyInfo = EntryK+    type AttrGetType EntryTextLengthPropertyInfo = Word32+    type AttrLabel EntryTextLengthPropertyInfo = "Entry::text-length"+    attrGet _ = getEntryTextLength+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "truncate-multiline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryTruncateMultiline :: (MonadIO m, EntryK o) => o -> m Bool+getEntryTruncateMultiline obj = liftIO $ getObjectPropertyBool obj "truncate-multiline"++setEntryTruncateMultiline :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryTruncateMultiline obj val = liftIO $ setObjectPropertyBool obj "truncate-multiline" val++constructEntryTruncateMultiline :: Bool -> IO ([Char], GValue)+constructEntryTruncateMultiline val = constructObjectPropertyBool "truncate-multiline" val++data EntryTruncateMultilinePropertyInfo+instance AttrInfo EntryTruncateMultilinePropertyInfo where+    type AttrAllowedOps EntryTruncateMultilinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryTruncateMultilinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryTruncateMultilinePropertyInfo = EntryK+    type AttrGetType EntryTruncateMultilinePropertyInfo = Bool+    type AttrLabel EntryTruncateMultilinePropertyInfo = "Entry::truncate-multiline"+    attrGet _ = getEntryTruncateMultiline+    attrSet _ = setEntryTruncateMultiline+    attrConstruct _ = constructEntryTruncateMultiline++-- VVV Prop "visibility"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryVisibility :: (MonadIO m, EntryK o) => o -> m Bool+getEntryVisibility obj = liftIO $ getObjectPropertyBool obj "visibility"++setEntryVisibility :: (MonadIO m, EntryK o) => o -> Bool -> m ()+setEntryVisibility obj val = liftIO $ setObjectPropertyBool obj "visibility" val++constructEntryVisibility :: Bool -> IO ([Char], GValue)+constructEntryVisibility val = constructObjectPropertyBool "visibility" val++data EntryVisibilityPropertyInfo+instance AttrInfo EntryVisibilityPropertyInfo where+    type AttrAllowedOps EntryVisibilityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryVisibilityPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryVisibilityPropertyInfo = EntryK+    type AttrGetType EntryVisibilityPropertyInfo = Bool+    type AttrLabel EntryVisibilityPropertyInfo = "Entry::visibility"+    attrGet _ = getEntryVisibility+    attrSet _ = setEntryVisibility+    attrConstruct _ = constructEntryVisibility++-- VVV Prop "width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryWidthChars :: (MonadIO m, EntryK o) => o -> m Int32+getEntryWidthChars obj = liftIO $ getObjectPropertyCInt obj "width-chars"++setEntryWidthChars :: (MonadIO m, EntryK o) => o -> Int32 -> m ()+setEntryWidthChars obj val = liftIO $ setObjectPropertyCInt obj "width-chars" val++constructEntryWidthChars :: Int32 -> IO ([Char], GValue)+constructEntryWidthChars val = constructObjectPropertyCInt "width-chars" val++data EntryWidthCharsPropertyInfo+instance AttrInfo EntryWidthCharsPropertyInfo where+    type AttrAllowedOps EntryWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryWidthCharsPropertyInfo = EntryK+    type AttrGetType EntryWidthCharsPropertyInfo = Int32+    type AttrLabel EntryWidthCharsPropertyInfo = "Entry::width-chars"+    attrGet _ = getEntryWidthChars+    attrSet _ = setEntryWidthChars+    attrConstruct _ = constructEntryWidthChars++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryXalign :: (MonadIO m, EntryK o) => o -> m Float+getEntryXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setEntryXalign :: (MonadIO m, EntryK o) => o -> Float -> m ()+setEntryXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructEntryXalign :: Float -> IO ([Char], GValue)+constructEntryXalign val = constructObjectPropertyFloat "xalign" val++data EntryXalignPropertyInfo+instance AttrInfo EntryXalignPropertyInfo where+    type AttrAllowedOps EntryXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint EntryXalignPropertyInfo = EntryK+    type AttrGetType EntryXalignPropertyInfo = Float+    type AttrLabel EntryXalignPropertyInfo = "Entry::xalign"+    attrGet _ = getEntryXalign+    attrSet _ = setEntryXalign+    attrConstruct _ = constructEntryXalign++type instance AttributeList Entry = EntryAttributeList+type EntryAttributeList = ('[ '("activates-default", EntryActivatesDefaultPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("attributes", EntryAttributesPropertyInfo), '("buffer", EntryBufferPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("caps-lock-warning", EntryCapsLockWarningPropertyInfo), '("completion", EntryCompletionPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("cursor-position", EntryCursorPositionPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("editable", EntryEditablePropertyInfo), '("editing-canceled", CellEditableEditingCanceledPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-frame", EntryHasFramePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("im-module", EntryImModulePropertyInfo), '("inner-border", EntryInnerBorderPropertyInfo), '("input-hints", EntryInputHintsPropertyInfo), '("input-purpose", EntryInputPurposePropertyInfo), '("invisible-char", EntryInvisibleCharPropertyInfo), '("invisible-char-set", EntryInvisibleCharSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-length", EntryMaxLengthPropertyInfo), '("max-width-chars", EntryMaxWidthCharsPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("overwrite-mode", EntryOverwriteModePropertyInfo), '("parent", WidgetParentPropertyInfo), '("placeholder-text", EntryPlaceholderTextPropertyInfo), '("populate-all", EntryPopulateAllPropertyInfo), '("primary-icon-activatable", EntryPrimaryIconActivatablePropertyInfo), '("primary-icon-gicon", EntryPrimaryIconGiconPropertyInfo), '("primary-icon-name", EntryPrimaryIconNamePropertyInfo), '("primary-icon-pixbuf", EntryPrimaryIconPixbufPropertyInfo), '("primary-icon-sensitive", EntryPrimaryIconSensitivePropertyInfo), '("primary-icon-stock", EntryPrimaryIconStockPropertyInfo), '("primary-icon-storage-type", EntryPrimaryIconStorageTypePropertyInfo), '("primary-icon-tooltip-markup", EntryPrimaryIconTooltipMarkupPropertyInfo), '("primary-icon-tooltip-text", EntryPrimaryIconTooltipTextPropertyInfo), '("progress-fraction", EntryProgressFractionPropertyInfo), '("progress-pulse-step", EntryProgressPulseStepPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("scroll-offset", EntryScrollOffsetPropertyInfo), '("secondary-icon-activatable", EntrySecondaryIconActivatablePropertyInfo), '("secondary-icon-gicon", EntrySecondaryIconGiconPropertyInfo), '("secondary-icon-name", EntrySecondaryIconNamePropertyInfo), '("secondary-icon-pixbuf", EntrySecondaryIconPixbufPropertyInfo), '("secondary-icon-sensitive", EntrySecondaryIconSensitivePropertyInfo), '("secondary-icon-stock", EntrySecondaryIconStockPropertyInfo), '("secondary-icon-storage-type", EntrySecondaryIconStorageTypePropertyInfo), '("secondary-icon-tooltip-markup", EntrySecondaryIconTooltipMarkupPropertyInfo), '("secondary-icon-tooltip-text", EntrySecondaryIconTooltipTextPropertyInfo), '("selection-bound", EntrySelectionBoundPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", EntryShadowTypePropertyInfo), '("style", WidgetStylePropertyInfo), '("tabs", EntryTabsPropertyInfo), '("text", EntryTextPropertyInfo), '("text-length", EntryTextLengthPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("truncate-multiline", EntryTruncateMultilinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visibility", EntryVisibilityPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-chars", EntryWidthCharsPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", EntryXalignPropertyInfo)] :: [(Symbol, *)])++data EntryActivateSignalInfo+instance SignalInfo EntryActivateSignalInfo where+    type HaskellCallbackType EntryActivateSignalInfo = EntryActivateCallback+    connectSignal _ = connectEntryActivate++data EntryBackspaceSignalInfo+instance SignalInfo EntryBackspaceSignalInfo where+    type HaskellCallbackType EntryBackspaceSignalInfo = EntryBackspaceCallback+    connectSignal _ = connectEntryBackspace++data EntryCopyClipboardSignalInfo+instance SignalInfo EntryCopyClipboardSignalInfo where+    type HaskellCallbackType EntryCopyClipboardSignalInfo = EntryCopyClipboardCallback+    connectSignal _ = connectEntryCopyClipboard++data EntryCutClipboardSignalInfo+instance SignalInfo EntryCutClipboardSignalInfo where+    type HaskellCallbackType EntryCutClipboardSignalInfo = EntryCutClipboardCallback+    connectSignal _ = connectEntryCutClipboard++data EntryDeleteFromCursorSignalInfo+instance SignalInfo EntryDeleteFromCursorSignalInfo where+    type HaskellCallbackType EntryDeleteFromCursorSignalInfo = EntryDeleteFromCursorCallback+    connectSignal _ = connectEntryDeleteFromCursor++data EntryIconPressSignalInfo+instance SignalInfo EntryIconPressSignalInfo where+    type HaskellCallbackType EntryIconPressSignalInfo = EntryIconPressCallback+    connectSignal _ = connectEntryIconPress++data EntryIconReleaseSignalInfo+instance SignalInfo EntryIconReleaseSignalInfo where+    type HaskellCallbackType EntryIconReleaseSignalInfo = EntryIconReleaseCallback+    connectSignal _ = connectEntryIconRelease++data EntryInsertAtCursorSignalInfo+instance SignalInfo EntryInsertAtCursorSignalInfo where+    type HaskellCallbackType EntryInsertAtCursorSignalInfo = EntryInsertAtCursorCallback+    connectSignal _ = connectEntryInsertAtCursor++data EntryMoveCursorSignalInfo+instance SignalInfo EntryMoveCursorSignalInfo where+    type HaskellCallbackType EntryMoveCursorSignalInfo = EntryMoveCursorCallback+    connectSignal _ = connectEntryMoveCursor++data EntryPasteClipboardSignalInfo+instance SignalInfo EntryPasteClipboardSignalInfo where+    type HaskellCallbackType EntryPasteClipboardSignalInfo = EntryPasteClipboardCallback+    connectSignal _ = connectEntryPasteClipboard++data EntryPopulatePopupSignalInfo+instance SignalInfo EntryPopulatePopupSignalInfo where+    type HaskellCallbackType EntryPopulatePopupSignalInfo = EntryPopulatePopupCallback+    connectSignal _ = connectEntryPopulatePopup++data EntryPreeditChangedSignalInfo+instance SignalInfo EntryPreeditChangedSignalInfo where+    type HaskellCallbackType EntryPreeditChangedSignalInfo = EntryPreeditChangedCallback+    connectSignal _ = connectEntryPreeditChanged++data EntryToggleOverwriteSignalInfo+instance SignalInfo EntryToggleOverwriteSignalInfo where+    type HaskellCallbackType EntryToggleOverwriteSignalInfo = EntryToggleOverwriteCallback+    connectSignal _ = connectEntryToggleOverwrite++type instance SignalList Entry = EntrySignalList+type EntrySignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", EntryActivateSignalInfo), '("backspace", EntryBackspaceSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("changed", EditableChangedSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("copy-clipboard", EntryCopyClipboardSignalInfo), '("cut-clipboard", EntryCutClipboardSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("delete-from-cursor", EntryDeleteFromCursorSignalInfo), '("delete-text", EditableDeleteTextSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("editing-done", CellEditableEditingDoneSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("icon-press", EntryIconPressSignalInfo), '("icon-release", EntryIconReleaseSignalInfo), '("insert-at-cursor", EntryInsertAtCursorSignalInfo), '("insert-text", EditableInsertTextSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", EntryMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("paste-clipboard", EntryPasteClipboardSignalInfo), '("populate-popup", EntryPopulatePopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("preedit-changed", EntryPreeditChangedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove-widget", CellEditableRemoveWidgetSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-overwrite", EntryToggleOverwriteSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Entry::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Entry"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_new" gtk_entry_new :: +    IO (Ptr Entry)+++entryNew ::+    (MonadIO m) =>+    m Entry+entryNew  = liftIO $ do+    result <- gtk_entry_new+    checkUnexpectedReturnNULL "gtk_entry_new" result+    result' <- (newObject Entry) result+    return result'++-- method Entry::new_with_buffer+-- method type : Constructor+-- Args : [Arg {argName = "buffer", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "buffer", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Entry"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_new_with_buffer" gtk_entry_new_with_buffer :: +    Ptr EntryBuffer ->                      -- buffer : TInterface "Gtk" "EntryBuffer"+    IO (Ptr Entry)+++entryNewWithBuffer ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- buffer+    m Entry+entryNewWithBuffer buffer = liftIO $ do+    let buffer' = unsafeManagedPtrCastPtr buffer+    result <- gtk_entry_new_with_buffer buffer'+    checkUnexpectedReturnNULL "gtk_entry_new_with_buffer" result+    result' <- (newObject Entry) result+    touchManagedPtr buffer+    return result'++-- method Entry::get_activates_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_activates_default" gtk_entry_get_activates_default :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CInt+++entryGetActivatesDefault ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Bool+entryGetActivatesDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_activates_default _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_alignment" gtk_entry_get_alignment :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CFloat+++entryGetAlignment ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Float+entryGetAlignment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_alignment _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Entry::get_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "AttrList"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_attributes" gtk_entry_get_attributes :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr Pango.AttrList)+++entryGetAttributes ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Pango.AttrList+entryGetAttributes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_attributes _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_attributes" result+    result' <- (newBoxed Pango.AttrList) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "EntryBuffer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_buffer" gtk_entry_get_buffer :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr EntryBuffer)+++entryGetBuffer ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m EntryBuffer+entryGetBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_buffer _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_buffer" result+    result' <- (newObject EntryBuffer) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "EntryCompletion"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_completion" gtk_entry_get_completion :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr EntryCompletion)+++entryGetCompletion ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m EntryCompletion+entryGetCompletion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_completion _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_completion" result+    result' <- (newObject EntryCompletion) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_current_icon_drag_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_current_icon_drag_source" gtk_entry_get_current_icon_drag_source :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO Int32+++entryGetCurrentIconDragSource ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Int32+entryGetCurrentIconDragSource _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_current_icon_drag_source _obj'+    touchManagedPtr _obj+    return result++-- method Entry::get_cursor_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_cursor_hadjustment" gtk_entry_get_cursor_hadjustment :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr Adjustment)+++entryGetCursorHadjustment ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Adjustment+entryGetCursorHadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_cursor_hadjustment _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_cursor_hadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_has_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_has_frame" gtk_entry_get_has_frame :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CInt+++entryGetHasFrame ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Bool+entryGetHasFrame _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_has_frame _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_activatable" gtk_entry_get_icon_activatable :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CInt+++entryGetIconActivatable ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m Bool+entryGetIconActivatable _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_activatable _obj' icon_pos'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_area" gtk_entry_get_icon_area :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    Ptr Gdk.Rectangle ->                    -- icon_area : TInterface "Gdk" "Rectangle"+    IO ()+++entryGetIconArea ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m (Gdk.Rectangle)+entryGetIconArea _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    icon_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_entry_get_icon_area _obj' icon_pos' icon_area+    icon_area' <- (wrapBoxed Gdk.Rectangle) icon_area+    touchManagedPtr _obj+    return icon_area'++-- method Entry::get_icon_at_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_at_pos" gtk_entry_get_icon_at_pos :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO Int32+++entryGetIconAtPos ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- x+    Int32 ->                                -- y+    m Int32+entryGetIconAtPos _obj x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_icon_at_pos _obj' x y+    touchManagedPtr _obj+    return result++-- method Entry::get_icon_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_gicon" gtk_entry_get_icon_gicon :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO (Ptr Gio.Icon)+++entryGetIconGicon ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m Gio.Icon+entryGetIconGicon _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_gicon _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_gicon" result+    result' <- (newObject Gio.Icon) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_name" gtk_entry_get_icon_name :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CString+++entryGetIconName ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m T.Text+entryGetIconName _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_name _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_pixbuf" gtk_entry_get_icon_pixbuf :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO (Ptr GdkPixbuf.Pixbuf)+++entryGetIconPixbuf ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m GdkPixbuf.Pixbuf+entryGetIconPixbuf _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_pixbuf _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_pixbuf" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_sensitive" gtk_entry_get_icon_sensitive :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CInt+++entryGetIconSensitive ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m Bool+entryGetIconSensitive _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_sensitive _obj' icon_pos'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_stock" gtk_entry_get_icon_stock :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CString++{-# DEPRECATED entryGetIconStock ["(Since version 3.10)","Use gtk_entry_get_icon_name() instead."]#-}+entryGetIconStock ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m T.Text+entryGetIconStock _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_stock _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_stock" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_storage_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ImageType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_storage_type" gtk_entry_get_icon_storage_type :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CUInt+++entryGetIconStorageType ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m ImageType+entryGetIconStorageType _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_storage_type _obj' icon_pos'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_tooltip_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_tooltip_markup" gtk_entry_get_icon_tooltip_markup :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CString+++entryGetIconTooltipMarkup ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m T.Text+entryGetIconTooltipMarkup _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_tooltip_markup _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_tooltip_markup" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Entry::get_icon_tooltip_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_icon_tooltip_text" gtk_entry_get_icon_tooltip_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    IO CString+++entryGetIconTooltipText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    m T.Text+entryGetIconTooltipText _obj icon_pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    result <- gtk_entry_get_icon_tooltip_text _obj' icon_pos'+    checkUnexpectedReturnNULL "gtk_entry_get_icon_tooltip_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Entry::get_inner_border+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Border"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_inner_border" gtk_entry_get_inner_border :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr Border)++{-# DEPRECATED entryGetInnerBorder ["(Since version 3.4)","Use the standard border and padding CSS properties (through","  objects like #GtkStyleContext and #GtkCssProvider); the value returned by","  this function is ignored by #GtkEntry."]#-}+entryGetInnerBorder ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Border+entryGetInnerBorder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_inner_border _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_inner_border" result+    result' <- (newBoxed Border) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_input_hints+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "InputHints"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_input_hints" gtk_entry_get_input_hints :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CUInt+++entryGetInputHints ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m [InputHints]+entryGetInputHints _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_input_hints _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Entry::get_input_purpose+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "InputPurpose"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_input_purpose" gtk_entry_get_input_purpose :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CUInt+++entryGetInputPurpose ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m InputPurpose+entryGetInputPurpose _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_input_purpose _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_invisible_char+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUniChar+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_invisible_char" gtk_entry_get_invisible_char :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CInt+++entryGetInvisibleChar ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Char+entryGetInvisibleChar _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_invisible_char _obj'+    let result' = (chr . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "Layout"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_layout" gtk_entry_get_layout :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr Pango.Layout)+++entryGetLayout ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Pango.Layout+entryGetLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_layout _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_layout" result+    result' <- (newObject Pango.Layout) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_layout_offsets+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_layout_offsets" gtk_entry_get_layout_offsets :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Int32 ->                            -- x : TBasicType TInt32+    Ptr Int32 ->                            -- y : TBasicType TInt32+    IO ()+++entryGetLayoutOffsets ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+entryGetLayoutOffsets _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    x <- allocMem :: IO (Ptr Int32)+    y <- allocMem :: IO (Ptr Int32)+    gtk_entry_get_layout_offsets _obj' x y+    x' <- peek x+    y' <- peek y+    touchManagedPtr _obj+    freeMem x+    freeMem y+    return (x', y')++-- method Entry::get_max_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_max_length" gtk_entry_get_max_length :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO Int32+++entryGetMaxLength ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Int32+entryGetMaxLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_max_length _obj'+    touchManagedPtr _obj+    return result++-- method Entry::get_max_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_max_width_chars" gtk_entry_get_max_width_chars :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO Int32+++entryGetMaxWidthChars ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Int32+entryGetMaxWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_max_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method Entry::get_overwrite_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_overwrite_mode" gtk_entry_get_overwrite_mode :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CInt+++entryGetOverwriteMode ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Bool+entryGetOverwriteMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_overwrite_mode _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_placeholder_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_placeholder_text" gtk_entry_get_placeholder_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CString+++entryGetPlaceholderText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m T.Text+entryGetPlaceholderText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_placeholder_text _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_placeholder_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Entry::get_progress_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_progress_fraction" gtk_entry_get_progress_fraction :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CDouble+++entryGetProgressFraction ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Double+entryGetProgressFraction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_progress_fraction _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Entry::get_progress_pulse_step+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_progress_pulse_step" gtk_entry_get_progress_pulse_step :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CDouble+++entryGetProgressPulseStep ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Double+entryGetProgressPulseStep _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_progress_pulse_step _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Entry::get_tabs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "TabArray"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_tabs" gtk_entry_get_tabs :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO (Ptr Pango.TabArray)+++entryGetTabs ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Pango.TabArray+entryGetTabs _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_tabs _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_tabs" result+    result' <- (newBoxed Pango.TabArray) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_text" gtk_entry_get_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CString+++entryGetText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m T.Text+entryGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_text _obj'+    checkUnexpectedReturnNULL "gtk_entry_get_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Entry::get_text_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text_area", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_text_area" gtk_entry_get_text_area :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Gdk.Rectangle ->                    -- text_area : TInterface "Gdk" "Rectangle"+    IO ()+++entryGetTextArea ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m (Gdk.Rectangle)+entryGetTextArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text_area <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_entry_get_text_area _obj' text_area+    text_area' <- (wrapBoxed Gdk.Rectangle) text_area+    touchManagedPtr _obj+    return text_area'++-- method Entry::get_text_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_text_length" gtk_entry_get_text_length :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO Word16+++entryGetTextLength ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Word16+entryGetTextLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_text_length _obj'+    touchManagedPtr _obj+    return result++-- method Entry::get_visibility+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_visibility" gtk_entry_get_visibility :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO CInt+++entryGetVisibility ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Bool+entryGetVisibility _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_visibility _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Entry::get_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_get_width_chars" gtk_entry_get_width_chars :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO Int32+++entryGetWidthChars ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m Int32+entryGetWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_get_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method Entry::grab_focus_without_selecting+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_grab_focus_without_selecting" gtk_entry_grab_focus_without_selecting :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO ()+++entryGrabFocusWithoutSelecting ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m ()+entryGrabFocusWithoutSelecting _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_grab_focus_without_selecting _obj'+    touchManagedPtr _obj+    return ()++-- method Entry::im_context_filter_keypress+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_im_context_filter_keypress" gtk_entry_im_context_filter_keypress :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Gdk.EventKey ->                     -- event : TInterface "Gdk" "EventKey"+    IO CInt+++entryImContextFilterKeypress ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Gdk.EventKey ->                         -- event+    m Bool+entryImContextFilterKeypress _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    result <- gtk_entry_im_context_filter_keypress _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++-- method Entry::layout_index_to_text_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_layout_index_to_text_index" gtk_entry_layout_index_to_text_index :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- layout_index : TBasicType TInt32+    IO Int32+++entryLayoutIndexToTextIndex ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- layout_index+    m Int32+entryLayoutIndexToTextIndex _obj layout_index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_layout_index_to_text_index _obj' layout_index+    touchManagedPtr _obj+    return result++-- method Entry::progress_pulse+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_progress_pulse" gtk_entry_progress_pulse :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO ()+++entryProgressPulse ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m ()+entryProgressPulse _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_progress_pulse _obj'+    touchManagedPtr _obj+    return ()++-- method Entry::reset_im_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_reset_im_context" gtk_entry_reset_im_context :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO ()+++entryResetImContext ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m ()+entryResetImContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_reset_im_context _obj'+    touchManagedPtr _obj+    return ()++-- method Entry::set_activates_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_entry_set_activates_default" gtk_entry_set_activates_default :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++entrySetActivatesDefault ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+entrySetActivatesDefault _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_entry_set_activates_default _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Entry::set_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_alignment" gtk_entry_set_alignment :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CFloat ->                               -- xalign : TBasicType TFloat+    IO ()+++entrySetAlignment ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    m ()+entrySetAlignment _obj xalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    gtk_entry_set_alignment _obj' xalign'+    touchManagedPtr _obj+    return ()++-- method Entry::set_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attrs", argType = TInterface "Pango" "AttrList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attrs", argType = TInterface "Pango" "AttrList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_attributes" gtk_entry_set_attributes :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Pango.AttrList ->                   -- attrs : TInterface "Pango" "AttrList"+    IO ()+++entrySetAttributes ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Pango.AttrList ->                       -- attrs+    m ()+entrySetAttributes _obj attrs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let attrs' = unsafeManagedPtrGetPtr attrs+    gtk_entry_set_attributes _obj' attrs'+    touchManagedPtr _obj+    touchManagedPtr attrs+    return ()++-- method Entry::set_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "buffer", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_buffer" gtk_entry_set_buffer :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr EntryBuffer ->                      -- buffer : TInterface "Gtk" "EntryBuffer"+    IO ()+++entrySetBuffer ::+    (MonadIO m, EntryK a, EntryBufferK b) =>+    a ->                                    -- _obj+    b ->                                    -- buffer+    m ()+entrySetBuffer _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let buffer' = unsafeManagedPtrCastPtr buffer+    gtk_entry_set_buffer _obj' buffer'+    touchManagedPtr _obj+    touchManagedPtr buffer+    return ()++-- method Entry::set_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "completion", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "completion", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_completion" gtk_entry_set_completion :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr EntryCompletion ->                  -- completion : TInterface "Gtk" "EntryCompletion"+    IO ()+++entrySetCompletion ::+    (MonadIO m, EntryK a, EntryCompletionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- completion+    m ()+entrySetCompletion _obj completion = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeCompletion <- case completion of+        Nothing -> return nullPtr+        Just jCompletion -> do+            let jCompletion' = unsafeManagedPtrCastPtr jCompletion+            return jCompletion'+    gtk_entry_set_completion _obj' maybeCompletion+    touchManagedPtr _obj+    whenJust completion touchManagedPtr+    return ()++-- method Entry::set_cursor_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_cursor_hadjustment" gtk_entry_set_cursor_hadjustment :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++entrySetCursorHadjustment ::+    (MonadIO m, EntryK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+entrySetCursorHadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_entry_set_cursor_hadjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method Entry::set_has_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_entry_set_has_frame" gtk_entry_set_has_frame :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++entrySetHasFrame ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+entrySetHasFrame _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_entry_set_has_frame _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Entry::set_icon_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activatable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activatable", 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 "gtk_entry_set_icon_activatable" gtk_entry_set_icon_activatable :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CInt ->                                 -- activatable : TBasicType TBoolean+    IO ()+++entrySetIconActivatable ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Bool ->                                 -- activatable+    m ()+entrySetIconActivatable _obj icon_pos activatable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    let activatable' = (fromIntegral . fromEnum) activatable+    gtk_entry_set_icon_activatable _obj' icon_pos' activatable'+    touchManagedPtr _obj+    return ()++-- method Entry::set_icon_drag_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_list", argType = TInterface "Gtk" "TargetList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "target_list", argType = TInterface "Gtk" "TargetList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_icon_drag_source" gtk_entry_set_icon_drag_source :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    Ptr TargetList ->                       -- target_list : TInterface "Gtk" "TargetList"+    CUInt ->                                -- actions : TInterface "Gdk" "DragAction"+    IO ()+++entrySetIconDragSource ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    TargetList ->                           -- target_list+    [Gdk.DragAction] ->                     -- actions+    m ()+entrySetIconDragSource _obj icon_pos target_list actions = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    let target_list' = unsafeManagedPtrGetPtr target_list+    let actions' = gflagsToWord actions+    gtk_entry_set_icon_drag_source _obj' icon_pos' target_list' actions'+    touchManagedPtr _obj+    touchManagedPtr target_list+    return ()++-- method Entry::set_icon_from_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_icon_from_gicon" gtk_entry_set_icon_from_gicon :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    IO ()+++entrySetIconFromGicon ::+    (MonadIO m, EntryK a, Gio.IconK b) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (b) ->                            -- icon+    m ()+entrySetIconFromGicon _obj icon_pos icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybeIcon <- case icon of+        Nothing -> return nullPtr+        Just jIcon -> do+            let jIcon' = unsafeManagedPtrCastPtr jIcon+            return jIcon'+    gtk_entry_set_icon_from_gicon _obj' icon_pos' maybeIcon+    touchManagedPtr _obj+    whenJust icon touchManagedPtr+    return ()++-- method Entry::set_icon_from_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", 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 "gtk_entry_set_icon_from_icon_name" gtk_entry_set_icon_from_icon_name :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO ()+++entrySetIconFromIconName ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (T.Text) ->                       -- icon_name+    m ()+entrySetIconFromIconName _obj icon_pos icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybeIcon_name <- case icon_name of+        Nothing -> return nullPtr+        Just jIcon_name -> do+            jIcon_name' <- textToCString jIcon_name+            return jIcon_name'+    gtk_entry_set_icon_from_icon_name _obj' icon_pos' maybeIcon_name+    touchManagedPtr _obj+    freeMem maybeIcon_name+    return ()++-- method Entry::set_icon_from_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_icon_from_pixbuf" gtk_entry_set_icon_from_pixbuf :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()+++entrySetIconFromPixbuf ::+    (MonadIO m, EntryK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (b) ->                            -- pixbuf+    m ()+entrySetIconFromPixbuf _obj icon_pos pixbuf = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybePixbuf <- case pixbuf of+        Nothing -> return nullPtr+        Just jPixbuf -> do+            let jPixbuf' = unsafeManagedPtrCastPtr jPixbuf+            return jPixbuf'+    gtk_entry_set_icon_from_pixbuf _obj' icon_pos' maybePixbuf+    touchManagedPtr _obj+    whenJust pixbuf touchManagedPtr+    return ()++-- method Entry::set_icon_from_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_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 "gtk_entry_set_icon_from_stock" gtk_entry_set_icon_from_stock :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CString ->                              -- stock_id : TBasicType TUTF8+    IO ()++{-# DEPRECATED entrySetIconFromStock ["(Since version 3.10)","Use gtk_entry_set_icon_from_icon_name() instead."]#-}+entrySetIconFromStock ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (T.Text) ->                       -- stock_id+    m ()+entrySetIconFromStock _obj icon_pos stock_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybeStock_id <- case stock_id of+        Nothing -> return nullPtr+        Just jStock_id -> do+            jStock_id' <- textToCString jStock_id+            return jStock_id'+    gtk_entry_set_icon_from_stock _obj' icon_pos' maybeStock_id+    touchManagedPtr _obj+    freeMem maybeStock_id+    return ()++-- method Entry::set_icon_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitive", 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 "gtk_entry_set_icon_sensitive" gtk_entry_set_icon_sensitive :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CInt ->                                 -- sensitive : TBasicType TBoolean+    IO ()+++entrySetIconSensitive ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Bool ->                                 -- sensitive+    m ()+entrySetIconSensitive _obj icon_pos sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    let sensitive' = (fromIntegral . fromEnum) sensitive+    gtk_entry_set_icon_sensitive _obj' icon_pos' sensitive'+    touchManagedPtr _obj+    return ()++-- method Entry::set_icon_tooltip_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", 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 "gtk_entry_set_icon_tooltip_markup" gtk_entry_set_icon_tooltip_markup :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CString ->                              -- tooltip : TBasicType TUTF8+    IO ()+++entrySetIconTooltipMarkup ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (T.Text) ->                       -- tooltip+    m ()+entrySetIconTooltipMarkup _obj icon_pos tooltip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    gtk_entry_set_icon_tooltip_markup _obj' icon_pos' maybeTooltip+    touchManagedPtr _obj+    freeMem maybeTooltip+    return ()++-- method Entry::set_icon_tooltip_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_pos", argType = TInterface "Gtk" "EntryIconPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", 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 "gtk_entry_set_icon_tooltip_text" gtk_entry_set_icon_tooltip_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- icon_pos : TInterface "Gtk" "EntryIconPosition"+    CString ->                              -- tooltip : TBasicType TUTF8+    IO ()+++entrySetIconTooltipText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    EntryIconPosition ->                    -- icon_pos+    Maybe (T.Text) ->                       -- tooltip+    m ()+entrySetIconTooltipText _obj icon_pos tooltip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_pos' = (fromIntegral . fromEnum) icon_pos+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    gtk_entry_set_icon_tooltip_text _obj' icon_pos' maybeTooltip+    touchManagedPtr _obj+    freeMem maybeTooltip+    return ()++-- method Entry::set_inner_border+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border", argType = TInterface "Gtk" "Border", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border", argType = TInterface "Gtk" "Border", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_inner_border" gtk_entry_set_inner_border :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Border ->                           -- border : TInterface "Gtk" "Border"+    IO ()++{-# DEPRECATED entrySetInnerBorder ["(Since version 3.4)","Use the standard border and padding CSS properties (through","  objects like #GtkStyleContext and #GtkCssProvider); the value set with","  this function is ignored by #GtkEntry."]#-}+entrySetInnerBorder ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Maybe (Border) ->                       -- border+    m ()+entrySetInnerBorder _obj border = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeBorder <- case border of+        Nothing -> return nullPtr+        Just jBorder -> do+            let jBorder' = unsafeManagedPtrGetPtr jBorder+            return jBorder'+    gtk_entry_set_inner_border _obj' maybeBorder+    touchManagedPtr _obj+    whenJust border touchManagedPtr+    return ()++-- method Entry::set_input_hints+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hints", argType = TInterface "Gtk" "InputHints", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "hints", argType = TInterface "Gtk" "InputHints", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_input_hints" gtk_entry_set_input_hints :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- hints : TInterface "Gtk" "InputHints"+    IO ()+++entrySetInputHints ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    [InputHints] ->                         -- hints+    m ()+entrySetInputHints _obj hints = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let hints' = gflagsToWord hints+    gtk_entry_set_input_hints _obj' hints'+    touchManagedPtr _obj+    return ()++-- method Entry::set_input_purpose+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TInterface "Gtk" "InputPurpose", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "purpose", argType = TInterface "Gtk" "InputPurpose", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_input_purpose" gtk_entry_set_input_purpose :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CUInt ->                                -- purpose : TInterface "Gtk" "InputPurpose"+    IO ()+++entrySetInputPurpose ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    InputPurpose ->                         -- purpose+    m ()+entrySetInputPurpose _obj purpose = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let purpose' = (fromIntegral . fromEnum) purpose+    gtk_entry_set_input_purpose _obj' purpose'+    touchManagedPtr _obj+    return ()++-- method Entry::set_invisible_char+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ch", argType = TBasicType TUniChar, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ch", argType = TBasicType TUniChar, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_invisible_char" gtk_entry_set_invisible_char :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CInt ->                                 -- ch : TBasicType TUniChar+    IO ()+++entrySetInvisibleChar ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Char ->                                 -- ch+    m ()+entrySetInvisibleChar _obj ch = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let ch' = (fromIntegral . ord) ch+    gtk_entry_set_invisible_char _obj' ch'+    touchManagedPtr _obj+    return ()++-- method Entry::set_max_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", 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 "gtk_entry_set_max_length" gtk_entry_set_max_length :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- max : TBasicType TInt32+    IO ()+++entrySetMaxLength ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- max+    m ()+entrySetMaxLength _obj max = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_set_max_length _obj' max+    touchManagedPtr _obj+    return ()++-- method Entry::set_max_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_entry_set_max_width_chars" gtk_entry_set_max_width_chars :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++entrySetMaxWidthChars ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_chars+    m ()+entrySetMaxWidthChars _obj n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_set_max_width_chars _obj' n_chars+    touchManagedPtr _obj+    return ()++-- method Entry::set_overwrite_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", 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 "Gtk" "Entry", 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 "gtk_entry_set_overwrite_mode" gtk_entry_set_overwrite_mode :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CInt ->                                 -- overwrite : TBasicType TBoolean+    IO ()+++entrySetOverwriteMode ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- overwrite+    m ()+entrySetOverwriteMode _obj overwrite = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let overwrite' = (fromIntegral . fromEnum) overwrite+    gtk_entry_set_overwrite_mode _obj' overwrite'+    touchManagedPtr _obj+    return ()++-- method Entry::set_placeholder_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_entry_set_placeholder_text" gtk_entry_set_placeholder_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++entrySetPlaceholderText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+entrySetPlaceholderText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_entry_set_placeholder_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method Entry::set_progress_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_progress_fraction" gtk_entry_set_progress_fraction :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CDouble ->                              -- fraction : TBasicType TDouble+    IO ()+++entrySetProgressFraction ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Double ->                               -- fraction+    m ()+entrySetProgressFraction _obj fraction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fraction' = realToFrac fraction+    gtk_entry_set_progress_fraction _obj' fraction'+    touchManagedPtr _obj+    return ()++-- method Entry::set_progress_pulse_step+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_progress_pulse_step" gtk_entry_set_progress_pulse_step :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CDouble ->                              -- fraction : TBasicType TDouble+    IO ()+++entrySetProgressPulseStep ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Double ->                               -- fraction+    m ()+entrySetProgressPulseStep _obj fraction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fraction' = realToFrac fraction+    gtk_entry_set_progress_pulse_step _obj' fraction'+    touchManagedPtr _obj+    return ()++-- method Entry::set_tabs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tabs", argType = TInterface "Pango" "TabArray", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tabs", argType = TInterface "Pango" "TabArray", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_set_tabs" gtk_entry_set_tabs :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Ptr Pango.TabArray ->                   -- tabs : TInterface "Pango" "TabArray"+    IO ()+++entrySetTabs ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Pango.TabArray ->                       -- tabs+    m ()+entrySetTabs _obj tabs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let tabs' = unsafeManagedPtrGetPtr tabs+    gtk_entry_set_tabs _obj' tabs'+    touchManagedPtr _obj+    touchManagedPtr tabs+    return ()++-- method Entry::set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_entry_set_text" gtk_entry_set_text :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++entrySetText ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+entrySetText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_entry_set_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method Entry::set_visibility+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", 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 "gtk_entry_set_visibility" gtk_entry_set_visibility :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    CInt ->                                 -- visible : TBasicType TBoolean+    IO ()+++entrySetVisibility ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible+    m ()+entrySetVisibility _obj visible = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible' = (fromIntegral . fromEnum) visible+    gtk_entry_set_visibility _obj' visible'+    touchManagedPtr _obj+    return ()++-- method Entry::set_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_entry_set_width_chars" gtk_entry_set_width_chars :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++entrySetWidthChars ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_chars+    m ()+entrySetWidthChars _obj n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_set_width_chars _obj' n_chars+    touchManagedPtr _obj+    return ()++-- method Entry::text_index_to_layout_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_text_index_to_layout_index" gtk_entry_text_index_to_layout_index :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    Int32 ->                                -- text_index : TBasicType TInt32+    IO Int32+++entryTextIndexToLayoutIndex ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- text_index+    m Int32+entryTextIndexToLayoutIndex _obj text_index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_text_index_to_layout_index _obj' text_index+    touchManagedPtr _obj+    return result++-- method Entry::unset_invisible_char+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Entry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_unset_invisible_char" gtk_entry_unset_invisible_char :: +    Ptr Entry ->                            -- _obj : TInterface "Gtk" "Entry"+    IO ()+++entryUnsetInvisibleChar ::+    (MonadIO m, EntryK a) =>+    a ->                                    -- _obj+    m ()+entryUnsetInvisibleChar _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_unset_invisible_char _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Entry.hs-boot view
@@ -0,0 +1,75 @@+module GI.Gtk.Objects.Entry where++import Prelude ()+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 Entry = Entry (ForeignPtr Entry)+instance GObject Entry where+class GObject o => EntryK o+instance (GObject o, IsDescendantOf Entry o) => EntryK o+data EntryActivatesDefaultPropertyInfo+data EntryAttributesPropertyInfo+data EntryBufferPropertyInfo+data EntryCapsLockWarningPropertyInfo+data EntryCompletionPropertyInfo+data EntryCursorPositionPropertyInfo+data EntryEditablePropertyInfo+data EntryHasFramePropertyInfo+data EntryImModulePropertyInfo+data EntryInnerBorderPropertyInfo+data EntryInputHintsPropertyInfo+data EntryInputPurposePropertyInfo+data EntryInvisibleCharPropertyInfo+data EntryInvisibleCharSetPropertyInfo+data EntryMaxLengthPropertyInfo+data EntryMaxWidthCharsPropertyInfo+data EntryOverwriteModePropertyInfo+data EntryPlaceholderTextPropertyInfo+data EntryPopulateAllPropertyInfo+data EntryPrimaryIconActivatablePropertyInfo+data EntryPrimaryIconGiconPropertyInfo+data EntryPrimaryIconNamePropertyInfo+data EntryPrimaryIconPixbufPropertyInfo+data EntryPrimaryIconSensitivePropertyInfo+data EntryPrimaryIconStockPropertyInfo+data EntryPrimaryIconStorageTypePropertyInfo+data EntryPrimaryIconTooltipMarkupPropertyInfo+data EntryPrimaryIconTooltipTextPropertyInfo+data EntryProgressFractionPropertyInfo+data EntryProgressPulseStepPropertyInfo+data EntryScrollOffsetPropertyInfo+data EntrySecondaryIconActivatablePropertyInfo+data EntrySecondaryIconGiconPropertyInfo+data EntrySecondaryIconNamePropertyInfo+data EntrySecondaryIconPixbufPropertyInfo+data EntrySecondaryIconSensitivePropertyInfo+data EntrySecondaryIconStockPropertyInfo+data EntrySecondaryIconStorageTypePropertyInfo+data EntrySecondaryIconTooltipMarkupPropertyInfo+data EntrySecondaryIconTooltipTextPropertyInfo+data EntrySelectionBoundPropertyInfo+data EntryShadowTypePropertyInfo+data EntryTabsPropertyInfo+data EntryTextPropertyInfo+data EntryTextLengthPropertyInfo+data EntryTruncateMultilinePropertyInfo+data EntryVisibilityPropertyInfo+data EntryWidthCharsPropertyInfo+data EntryXalignPropertyInfo+data EntryActivateSignalInfo+data EntryBackspaceSignalInfo+data EntryCopyClipboardSignalInfo+data EntryCutClipboardSignalInfo+data EntryDeleteFromCursorSignalInfo+data EntryIconPressSignalInfo+data EntryIconReleaseSignalInfo+data EntryInsertAtCursorSignalInfo+data EntryMoveCursorSignalInfo+data EntryPasteClipboardSignalInfo+data EntryPopulatePopupSignalInfo+data EntryPreeditChangedSignalInfo+data EntryToggleOverwriteSignalInfo
+ GI/Gtk/Objects/EntryAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.EntryAccessible+    ( ++-- * Exported types+    EntryAccessible(..)                     ,+    EntryAccessibleK                        ,+    toEntryAccessible                       ,+    noEntryAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype EntryAccessible = EntryAccessible (ForeignPtr EntryAccessible)+foreign import ccall "gtk_entry_accessible_get_type"+    c_gtk_entry_accessible_get_type :: IO GType++type instance ParentTypes EntryAccessible = EntryAccessibleParentTypes+type EntryAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.EditableText, Atk.Text]++instance GObject EntryAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_entry_accessible_get_type+    ++class GObject o => EntryAccessibleK o+instance (GObject o, IsDescendantOf EntryAccessible o) => EntryAccessibleK o++toEntryAccessible :: EntryAccessibleK o => o -> IO EntryAccessible+toEntryAccessible = unsafeCastTo EntryAccessible++noEntryAccessible :: Maybe EntryAccessible+noEntryAccessible = Nothing++type instance AttributeList EntryAccessible = EntryAccessibleAttributeList+type EntryAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList EntryAccessible = EntryAccessibleSignalList+type EntryAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("text-attributes-changed", Atk.TextTextAttributesChangedSignalInfo), '("text-caret-moved", Atk.TextTextCaretMovedSignalInfo), '("text-changed", Atk.TextTextChangedSignalInfo), '("text-insert", Atk.TextTextInsertSignalInfo), '("text-remove", Atk.TextTextRemoveSignalInfo), '("text-selection-changed", Atk.TextTextSelectionChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/EntryAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.EntryAccessible where++import Prelude ()+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 EntryAccessible = EntryAccessible (ForeignPtr EntryAccessible)+instance GObject EntryAccessible where+class GObject o => EntryAccessibleK o+instance (GObject o, IsDescendantOf EntryAccessible o) => EntryAccessibleK o
+ GI/Gtk/Objects/EntryBuffer.hs view
@@ -0,0 +1,628 @@++{- |+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.Gtk.Objects.EntryBuffer+    ( ++-- * Exported types+    EntryBuffer(..)                         ,+    EntryBufferK                            ,+    toEntryBuffer                           ,+    noEntryBuffer                           ,+++ -- * Methods+-- ** entryBufferDeleteText+    entryBufferDeleteText                   ,+++-- ** entryBufferEmitDeletedText+    entryBufferEmitDeletedText              ,+++-- ** entryBufferEmitInsertedText+    entryBufferEmitInsertedText             ,+++-- ** entryBufferGetBytes+    entryBufferGetBytes                     ,+++-- ** entryBufferGetLength+    entryBufferGetLength                    ,+++-- ** entryBufferGetMaxLength+    entryBufferGetMaxLength                 ,+++-- ** entryBufferGetText+    entryBufferGetText                      ,+++-- ** entryBufferInsertText+    entryBufferInsertText                   ,+++-- ** entryBufferNew+    entryBufferNew                          ,+++-- ** entryBufferSetMaxLength+    entryBufferSetMaxLength                 ,+++-- ** entryBufferSetText+    entryBufferSetText                      ,+++++ -- * Properties+-- ** Length+    EntryBufferLengthPropertyInfo           ,+    getEntryBufferLength                    ,+++-- ** MaxLength+    EntryBufferMaxLengthPropertyInfo        ,+    constructEntryBufferMaxLength           ,+    getEntryBufferMaxLength                 ,+    setEntryBufferMaxLength                 ,+++-- ** Text+    EntryBufferTextPropertyInfo             ,+    constructEntryBufferText                ,+    getEntryBufferText                      ,+    setEntryBufferText                      ,+++++ -- * Signals+-- ** DeletedText+    EntryBufferDeletedTextCallback          ,+    EntryBufferDeletedTextCallbackC         ,+    EntryBufferDeletedTextSignalInfo        ,+    afterEntryBufferDeletedText             ,+    entryBufferDeletedTextCallbackWrapper   ,+    entryBufferDeletedTextClosure           ,+    mkEntryBufferDeletedTextCallback        ,+    noEntryBufferDeletedTextCallback        ,+    onEntryBufferDeletedText                ,+++-- ** InsertedText+    EntryBufferInsertedTextCallback         ,+    EntryBufferInsertedTextCallbackC        ,+    EntryBufferInsertedTextSignalInfo       ,+    afterEntryBufferInsertedText            ,+    entryBufferInsertedTextCallbackWrapper  ,+    entryBufferInsertedTextClosure          ,+    mkEntryBufferInsertedTextCallback       ,+    noEntryBufferInsertedTextCallback       ,+    onEntryBufferInsertedText               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype EntryBuffer = EntryBuffer (ForeignPtr EntryBuffer)+foreign import ccall "gtk_entry_buffer_get_type"+    c_gtk_entry_buffer_get_type :: IO GType++type instance ParentTypes EntryBuffer = EntryBufferParentTypes+type EntryBufferParentTypes = '[GObject.Object]++instance GObject EntryBuffer where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_entry_buffer_get_type+    ++class GObject o => EntryBufferK o+instance (GObject o, IsDescendantOf EntryBuffer o) => EntryBufferK o++toEntryBuffer :: EntryBufferK o => o -> IO EntryBuffer+toEntryBuffer = unsafeCastTo EntryBuffer++noEntryBuffer :: Maybe EntryBuffer+noEntryBuffer = Nothing++-- signal EntryBuffer::deleted-text+type EntryBufferDeletedTextCallback =+    Word32 ->+    Word32 ->+    IO ()++noEntryBufferDeletedTextCallback :: Maybe EntryBufferDeletedTextCallback+noEntryBufferDeletedTextCallback = Nothing++type EntryBufferDeletedTextCallbackC =+    Ptr () ->                               -- object+    Word32 ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryBufferDeletedTextCallback :: EntryBufferDeletedTextCallbackC -> IO (FunPtr EntryBufferDeletedTextCallbackC)++entryBufferDeletedTextClosure :: EntryBufferDeletedTextCallback -> IO Closure+entryBufferDeletedTextClosure cb = newCClosure =<< mkEntryBufferDeletedTextCallback wrapped+    where wrapped = entryBufferDeletedTextCallbackWrapper cb++entryBufferDeletedTextCallbackWrapper ::+    EntryBufferDeletedTextCallback ->+    Ptr () ->+    Word32 ->+    Word32 ->+    Ptr () ->+    IO ()+entryBufferDeletedTextCallbackWrapper _cb _ position n_chars _ = do+    _cb  position n_chars++onEntryBufferDeletedText :: (GObject a, MonadIO m) => a -> EntryBufferDeletedTextCallback -> m SignalHandlerId+onEntryBufferDeletedText obj cb = liftIO $ connectEntryBufferDeletedText obj cb SignalConnectBefore+afterEntryBufferDeletedText :: (GObject a, MonadIO m) => a -> EntryBufferDeletedTextCallback -> m SignalHandlerId+afterEntryBufferDeletedText obj cb = connectEntryBufferDeletedText obj cb SignalConnectAfter++connectEntryBufferDeletedText :: (GObject a, MonadIO m) =>+                                 a -> EntryBufferDeletedTextCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryBufferDeletedText obj cb after = liftIO $ do+    cb' <- mkEntryBufferDeletedTextCallback (entryBufferDeletedTextCallbackWrapper cb)+    connectSignalFunPtr obj "deleted-text" cb' after++-- signal EntryBuffer::inserted-text+type EntryBufferInsertedTextCallback =+    Word32 ->+    T.Text ->+    Word32 ->+    IO ()++noEntryBufferInsertedTextCallback :: Maybe EntryBufferInsertedTextCallback+noEntryBufferInsertedTextCallback = Nothing++type EntryBufferInsertedTextCallbackC =+    Ptr () ->                               -- object+    Word32 ->+    CString ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryBufferInsertedTextCallback :: EntryBufferInsertedTextCallbackC -> IO (FunPtr EntryBufferInsertedTextCallbackC)++entryBufferInsertedTextClosure :: EntryBufferInsertedTextCallback -> IO Closure+entryBufferInsertedTextClosure cb = newCClosure =<< mkEntryBufferInsertedTextCallback wrapped+    where wrapped = entryBufferInsertedTextCallbackWrapper cb++entryBufferInsertedTextCallbackWrapper ::+    EntryBufferInsertedTextCallback ->+    Ptr () ->+    Word32 ->+    CString ->+    Word32 ->+    Ptr () ->+    IO ()+entryBufferInsertedTextCallbackWrapper _cb _ position chars n_chars _ = do+    chars' <- cstringToText chars+    _cb  position chars' n_chars++onEntryBufferInsertedText :: (GObject a, MonadIO m) => a -> EntryBufferInsertedTextCallback -> m SignalHandlerId+onEntryBufferInsertedText obj cb = liftIO $ connectEntryBufferInsertedText obj cb SignalConnectBefore+afterEntryBufferInsertedText :: (GObject a, MonadIO m) => a -> EntryBufferInsertedTextCallback -> m SignalHandlerId+afterEntryBufferInsertedText obj cb = connectEntryBufferInsertedText obj cb SignalConnectAfter++connectEntryBufferInsertedText :: (GObject a, MonadIO m) =>+                                  a -> EntryBufferInsertedTextCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryBufferInsertedText obj cb after = liftIO $ do+    cb' <- mkEntryBufferInsertedTextCallback (entryBufferInsertedTextCallbackWrapper cb)+    connectSignalFunPtr obj "inserted-text" cb' after++-- VVV Prop "length"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable]++getEntryBufferLength :: (MonadIO m, EntryBufferK o) => o -> m Word32+getEntryBufferLength obj = liftIO $ getObjectPropertyCUInt obj "length"++data EntryBufferLengthPropertyInfo+instance AttrInfo EntryBufferLengthPropertyInfo where+    type AttrAllowedOps EntryBufferLengthPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint EntryBufferLengthPropertyInfo = (~) ()+    type AttrBaseTypeConstraint EntryBufferLengthPropertyInfo = EntryBufferK+    type AttrGetType EntryBufferLengthPropertyInfo = Word32+    type AttrLabel EntryBufferLengthPropertyInfo = "EntryBuffer::length"+    attrGet _ = getEntryBufferLength+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "max-length"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryBufferMaxLength :: (MonadIO m, EntryBufferK o) => o -> m Int32+getEntryBufferMaxLength obj = liftIO $ getObjectPropertyCInt obj "max-length"++setEntryBufferMaxLength :: (MonadIO m, EntryBufferK o) => o -> Int32 -> m ()+setEntryBufferMaxLength obj val = liftIO $ setObjectPropertyCInt obj "max-length" val++constructEntryBufferMaxLength :: Int32 -> IO ([Char], GValue)+constructEntryBufferMaxLength val = constructObjectPropertyCInt "max-length" val++data EntryBufferMaxLengthPropertyInfo+instance AttrInfo EntryBufferMaxLengthPropertyInfo where+    type AttrAllowedOps EntryBufferMaxLengthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryBufferMaxLengthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryBufferMaxLengthPropertyInfo = EntryBufferK+    type AttrGetType EntryBufferMaxLengthPropertyInfo = Int32+    type AttrLabel EntryBufferMaxLengthPropertyInfo = "EntryBuffer::max-length"+    attrGet _ = getEntryBufferMaxLength+    attrSet _ = setEntryBufferMaxLength+    attrConstruct _ = constructEntryBufferMaxLength++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryBufferText :: (MonadIO m, EntryBufferK o) => o -> m T.Text+getEntryBufferText obj = liftIO $ getObjectPropertyString obj "text"++setEntryBufferText :: (MonadIO m, EntryBufferK o) => o -> T.Text -> m ()+setEntryBufferText obj val = liftIO $ setObjectPropertyString obj "text" val++constructEntryBufferText :: T.Text -> IO ([Char], GValue)+constructEntryBufferText val = constructObjectPropertyString "text" val++data EntryBufferTextPropertyInfo+instance AttrInfo EntryBufferTextPropertyInfo where+    type AttrAllowedOps EntryBufferTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryBufferTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint EntryBufferTextPropertyInfo = EntryBufferK+    type AttrGetType EntryBufferTextPropertyInfo = T.Text+    type AttrLabel EntryBufferTextPropertyInfo = "EntryBuffer::text"+    attrGet _ = getEntryBufferText+    attrSet _ = setEntryBufferText+    attrConstruct _ = constructEntryBufferText++type instance AttributeList EntryBuffer = EntryBufferAttributeList+type EntryBufferAttributeList = ('[ '("length", EntryBufferLengthPropertyInfo), '("max-length", EntryBufferMaxLengthPropertyInfo), '("text", EntryBufferTextPropertyInfo)] :: [(Symbol, *)])++data EntryBufferDeletedTextSignalInfo+instance SignalInfo EntryBufferDeletedTextSignalInfo where+    type HaskellCallbackType EntryBufferDeletedTextSignalInfo = EntryBufferDeletedTextCallback+    connectSignal _ = connectEntryBufferDeletedText++data EntryBufferInsertedTextSignalInfo+instance SignalInfo EntryBufferInsertedTextSignalInfo where+    type HaskellCallbackType EntryBufferInsertedTextSignalInfo = EntryBufferInsertedTextCallback+    connectSignal _ = connectEntryBufferInsertedText++type instance SignalList EntryBuffer = EntryBufferSignalList+type EntryBufferSignalList = ('[ '("deleted-text", EntryBufferDeletedTextSignalInfo), '("inserted-text", EntryBufferInsertedTextSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method EntryBuffer::new+-- method type : Constructor+-- Args : [Arg {argName = "initial_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_initial_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "initial_chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_initial_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "EntryBuffer"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_new" gtk_entry_buffer_new :: +    CString ->                              -- initial_chars : TBasicType TUTF8+    Int32 ->                                -- n_initial_chars : TBasicType TInt32+    IO (Ptr EntryBuffer)+++entryBufferNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- initial_chars+    Int32 ->                                -- n_initial_chars+    m EntryBuffer+entryBufferNew initial_chars n_initial_chars = liftIO $ do+    maybeInitial_chars <- case initial_chars of+        Nothing -> return nullPtr+        Just jInitial_chars -> do+            jInitial_chars' <- textToCString jInitial_chars+            return jInitial_chars'+    result <- gtk_entry_buffer_new maybeInitial_chars n_initial_chars+    checkUnexpectedReturnNULL "gtk_entry_buffer_new" result+    result' <- (wrapObject EntryBuffer) result+    freeMem maybeInitial_chars+    return result'++-- method EntryBuffer::delete_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_delete_text" gtk_entry_buffer_delete_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    Word32 ->                               -- position : TBasicType TUInt32+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO Word32+++entryBufferDeleteText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    Int32 ->                                -- n_chars+    m Word32+entryBufferDeleteText _obj position n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_buffer_delete_text _obj' position n_chars+    touchManagedPtr _obj+    return result++-- method EntryBuffer::emit_deleted_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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_chars", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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_chars", 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 "gtk_entry_buffer_emit_deleted_text" gtk_entry_buffer_emit_deleted_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    Word32 ->                               -- position : TBasicType TUInt32+    Word32 ->                               -- n_chars : TBasicType TUInt32+    IO ()+++entryBufferEmitDeletedText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    Word32 ->                               -- n_chars+    m ()+entryBufferEmitDeletedText _obj position n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_buffer_emit_deleted_text _obj' position n_chars+    touchManagedPtr _obj+    return ()++-- method EntryBuffer::emit_inserted_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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 = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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 = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_entry_buffer_emit_inserted_text" gtk_entry_buffer_emit_inserted_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    Word32 ->                               -- position : TBasicType TUInt32+    CString ->                              -- chars : TBasicType TUTF8+    Word32 ->                               -- n_chars : TBasicType TUInt32+    IO ()+++entryBufferEmitInsertedText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    T.Text ->                               -- chars+    Word32 ->                               -- n_chars+    m ()+entryBufferEmitInsertedText _obj position chars n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    chars' <- textToCString chars+    gtk_entry_buffer_emit_inserted_text _obj' position chars' n_chars+    touchManagedPtr _obj+    freeMem chars'+    return ()++-- method EntryBuffer::get_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_get_bytes" gtk_entry_buffer_get_bytes :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    IO Word64+++entryBufferGetBytes ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    m Word64+entryBufferGetBytes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_buffer_get_bytes _obj'+    touchManagedPtr _obj+    return result++-- method EntryBuffer::get_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_get_length" gtk_entry_buffer_get_length :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    IO Word32+++entryBufferGetLength ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    m Word32+entryBufferGetLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_buffer_get_length _obj'+    touchManagedPtr _obj+    return result++-- method EntryBuffer::get_max_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_get_max_length" gtk_entry_buffer_get_max_length :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    IO Int32+++entryBufferGetMaxLength ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    m Int32+entryBufferGetMaxLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_buffer_get_max_length _obj'+    touchManagedPtr _obj+    return result++-- method EntryBuffer::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_get_text" gtk_entry_buffer_get_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    IO CString+++entryBufferGetText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    m T.Text+entryBufferGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_buffer_get_text _obj'+    checkUnexpectedReturnNULL "gtk_entry_buffer_get_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method EntryBuffer::insert_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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 = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", 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 = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_buffer_insert_text" gtk_entry_buffer_insert_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    Word32 ->                               -- position : TBasicType TUInt32+    CString ->                              -- chars : TBasicType TUTF8+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO Word32+++entryBufferInsertText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- position+    T.Text ->                               -- chars+    Int32 ->                                -- n_chars+    m Word32+entryBufferInsertText _obj position chars n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    chars' <- textToCString chars+    result <- gtk_entry_buffer_insert_text _obj' position chars' n_chars+    touchManagedPtr _obj+    freeMem chars'+    return result++-- method EntryBuffer::set_max_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max_length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max_length", 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 "gtk_entry_buffer_set_max_length" gtk_entry_buffer_set_max_length :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    Int32 ->                                -- max_length : TBasicType TInt32+    IO ()+++entryBufferSetMaxLength ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- max_length+    m ()+entryBufferSetMaxLength _obj max_length = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_buffer_set_max_length _obj' max_length+    touchManagedPtr _obj+    return ()++-- method EntryBuffer::set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryBuffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "chars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_entry_buffer_set_text" gtk_entry_buffer_set_text :: +    Ptr EntryBuffer ->                      -- _obj : TInterface "Gtk" "EntryBuffer"+    CString ->                              -- chars : TBasicType TUTF8+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++entryBufferSetText ::+    (MonadIO m, EntryBufferK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- chars+    Int32 ->                                -- n_chars+    m ()+entryBufferSetText _obj chars n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    chars' <- textToCString chars+    gtk_entry_buffer_set_text _obj' chars' n_chars+    touchManagedPtr _obj+    freeMem chars'+    return ()++
+ GI/Gtk/Objects/EntryBuffer.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.EntryBuffer where++import Prelude ()+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 EntryBuffer = EntryBuffer (ForeignPtr EntryBuffer)+instance GObject EntryBuffer where+class GObject o => EntryBufferK o+instance (GObject o, IsDescendantOf EntryBuffer o) => EntryBufferK o+data EntryBufferLengthPropertyInfo+data EntryBufferMaxLengthPropertyInfo+data EntryBufferTextPropertyInfo+data EntryBufferDeletedTextSignalInfo+data EntryBufferInsertedTextSignalInfo
+ GI/Gtk/Objects/EntryCompletion.hs view
@@ -0,0 +1,1469 @@++{- |+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.Gtk.Objects.EntryCompletion+    ( ++-- * Exported types+    EntryCompletion(..)                     ,+    EntryCompletionK                        ,+    toEntryCompletion                       ,+    noEntryCompletion                       ,+++ -- * Methods+-- ** entryCompletionComplete+    entryCompletionComplete                 ,+++-- ** entryCompletionComputePrefix+    entryCompletionComputePrefix            ,+++-- ** entryCompletionDeleteAction+    entryCompletionDeleteAction             ,+++-- ** entryCompletionGetCompletionPrefix+    entryCompletionGetCompletionPrefix      ,+++-- ** entryCompletionGetEntry+    entryCompletionGetEntry                 ,+++-- ** entryCompletionGetInlineCompletion+    entryCompletionGetInlineCompletion      ,+++-- ** entryCompletionGetInlineSelection+    entryCompletionGetInlineSelection       ,+++-- ** entryCompletionGetMinimumKeyLength+    entryCompletionGetMinimumKeyLength      ,+++-- ** entryCompletionGetModel+    entryCompletionGetModel                 ,+++-- ** entryCompletionGetPopupCompletion+    entryCompletionGetPopupCompletion       ,+++-- ** entryCompletionGetPopupSetWidth+    entryCompletionGetPopupSetWidth         ,+++-- ** entryCompletionGetPopupSingleMatch+    entryCompletionGetPopupSingleMatch      ,+++-- ** entryCompletionGetTextColumn+    entryCompletionGetTextColumn            ,+++-- ** entryCompletionInsertActionMarkup+    entryCompletionInsertActionMarkup       ,+++-- ** entryCompletionInsertActionText+    entryCompletionInsertActionText         ,+++-- ** entryCompletionInsertPrefix+    entryCompletionInsertPrefix             ,+++-- ** entryCompletionNew+    entryCompletionNew                      ,+++-- ** entryCompletionNewWithArea+    entryCompletionNewWithArea              ,+++-- ** entryCompletionSetInlineCompletion+    entryCompletionSetInlineCompletion      ,+++-- ** entryCompletionSetInlineSelection+    entryCompletionSetInlineSelection       ,+++-- ** entryCompletionSetMatchFunc+    entryCompletionSetMatchFunc             ,+++-- ** entryCompletionSetMinimumKeyLength+    entryCompletionSetMinimumKeyLength      ,+++-- ** entryCompletionSetModel+    entryCompletionSetModel                 ,+++-- ** entryCompletionSetPopupCompletion+    entryCompletionSetPopupCompletion       ,+++-- ** entryCompletionSetPopupSetWidth+    entryCompletionSetPopupSetWidth         ,+++-- ** entryCompletionSetPopupSingleMatch+    entryCompletionSetPopupSingleMatch      ,+++-- ** entryCompletionSetTextColumn+    entryCompletionSetTextColumn            ,+++++ -- * Properties+-- ** CellArea+    EntryCompletionCellAreaPropertyInfo     ,+    constructEntryCompletionCellArea        ,+    getEntryCompletionCellArea              ,+++-- ** InlineCompletion+    EntryCompletionInlineCompletionPropertyInfo,+    constructEntryCompletionInlineCompletion,+    getEntryCompletionInlineCompletion      ,+    setEntryCompletionInlineCompletion      ,+++-- ** InlineSelection+    EntryCompletionInlineSelectionPropertyInfo,+    constructEntryCompletionInlineSelection ,+    getEntryCompletionInlineSelection       ,+    setEntryCompletionInlineSelection       ,+++-- ** MinimumKeyLength+    EntryCompletionMinimumKeyLengthPropertyInfo,+    constructEntryCompletionMinimumKeyLength,+    getEntryCompletionMinimumKeyLength      ,+    setEntryCompletionMinimumKeyLength      ,+++-- ** Model+    EntryCompletionModelPropertyInfo        ,+    constructEntryCompletionModel           ,+    getEntryCompletionModel                 ,+    setEntryCompletionModel                 ,+++-- ** PopupCompletion+    EntryCompletionPopupCompletionPropertyInfo,+    constructEntryCompletionPopupCompletion ,+    getEntryCompletionPopupCompletion       ,+    setEntryCompletionPopupCompletion       ,+++-- ** PopupSetWidth+    EntryCompletionPopupSetWidthPropertyInfo,+    constructEntryCompletionPopupSetWidth   ,+    getEntryCompletionPopupSetWidth         ,+    setEntryCompletionPopupSetWidth         ,+++-- ** PopupSingleMatch+    EntryCompletionPopupSingleMatchPropertyInfo,+    constructEntryCompletionPopupSingleMatch,+    getEntryCompletionPopupSingleMatch      ,+    setEntryCompletionPopupSingleMatch      ,+++-- ** TextColumn+    EntryCompletionTextColumnPropertyInfo   ,+    constructEntryCompletionTextColumn      ,+    getEntryCompletionTextColumn            ,+    setEntryCompletionTextColumn            ,+++++ -- * Signals+-- ** ActionActivated+    EntryCompletionActionActivatedCallback  ,+    EntryCompletionActionActivatedCallbackC ,+    EntryCompletionActionActivatedSignalInfo,+    afterEntryCompletionActionActivated     ,+    entryCompletionActionActivatedCallbackWrapper,+    entryCompletionActionActivatedClosure   ,+    mkEntryCompletionActionActivatedCallback,+    noEntryCompletionActionActivatedCallback,+    onEntryCompletionActionActivated        ,+++-- ** CursorOnMatch+    EntryCompletionCursorOnMatchCallback    ,+    EntryCompletionCursorOnMatchCallbackC   ,+    EntryCompletionCursorOnMatchSignalInfo  ,+    afterEntryCompletionCursorOnMatch       ,+    entryCompletionCursorOnMatchCallbackWrapper,+    entryCompletionCursorOnMatchClosure     ,+    mkEntryCompletionCursorOnMatchCallback  ,+    noEntryCompletionCursorOnMatchCallback  ,+    onEntryCompletionCursorOnMatch          ,+++-- ** InsertPrefix+    EntryCompletionInsertPrefixCallback     ,+    EntryCompletionInsertPrefixCallbackC    ,+    EntryCompletionInsertPrefixSignalInfo   ,+    afterEntryCompletionInsertPrefix        ,+    entryCompletionInsertPrefixCallbackWrapper,+    entryCompletionInsertPrefixClosure      ,+    mkEntryCompletionInsertPrefixCallback   ,+    noEntryCompletionInsertPrefixCallback   ,+    onEntryCompletionInsertPrefix           ,+++-- ** MatchSelected+    EntryCompletionMatchSelectedCallback    ,+    EntryCompletionMatchSelectedCallbackC   ,+    EntryCompletionMatchSelectedSignalInfo  ,+    afterEntryCompletionMatchSelected       ,+    entryCompletionMatchSelectedCallbackWrapper,+    entryCompletionMatchSelectedClosure     ,+    mkEntryCompletionMatchSelectedCallback  ,+    noEntryCompletionMatchSelectedCallback  ,+    onEntryCompletionMatchSelected          ,+++-- ** NoMatches+    EntryCompletionNoMatchesCallback        ,+    EntryCompletionNoMatchesCallbackC       ,+    EntryCompletionNoMatchesSignalInfo      ,+    afterEntryCompletionNoMatches           ,+    entryCompletionNoMatchesCallbackWrapper ,+    entryCompletionNoMatchesClosure         ,+    mkEntryCompletionNoMatchesCallback      ,+    noEntryCompletionNoMatchesCallback      ,+    onEntryCompletionNoMatches              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype EntryCompletion = EntryCompletion (ForeignPtr EntryCompletion)+foreign import ccall "gtk_entry_completion_get_type"+    c_gtk_entry_completion_get_type :: IO GType++type instance ParentTypes EntryCompletion = EntryCompletionParentTypes+type EntryCompletionParentTypes = '[GObject.Object, Buildable, CellLayout]++instance GObject EntryCompletion where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_entry_completion_get_type+    ++class GObject o => EntryCompletionK o+instance (GObject o, IsDescendantOf EntryCompletion o) => EntryCompletionK o++toEntryCompletion :: EntryCompletionK o => o -> IO EntryCompletion+toEntryCompletion = unsafeCastTo EntryCompletion++noEntryCompletion :: Maybe EntryCompletion+noEntryCompletion = Nothing++-- signal EntryCompletion::action-activated+type EntryCompletionActionActivatedCallback =+    Int32 ->+    IO ()++noEntryCompletionActionActivatedCallback :: Maybe EntryCompletionActionActivatedCallback+noEntryCompletionActionActivatedCallback = Nothing++type EntryCompletionActionActivatedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryCompletionActionActivatedCallback :: EntryCompletionActionActivatedCallbackC -> IO (FunPtr EntryCompletionActionActivatedCallbackC)++entryCompletionActionActivatedClosure :: EntryCompletionActionActivatedCallback -> IO Closure+entryCompletionActionActivatedClosure cb = newCClosure =<< mkEntryCompletionActionActivatedCallback wrapped+    where wrapped = entryCompletionActionActivatedCallbackWrapper cb++entryCompletionActionActivatedCallbackWrapper ::+    EntryCompletionActionActivatedCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+entryCompletionActionActivatedCallbackWrapper _cb _ index _ = do+    _cb  index++onEntryCompletionActionActivated :: (GObject a, MonadIO m) => a -> EntryCompletionActionActivatedCallback -> m SignalHandlerId+onEntryCompletionActionActivated obj cb = liftIO $ connectEntryCompletionActionActivated obj cb SignalConnectBefore+afterEntryCompletionActionActivated :: (GObject a, MonadIO m) => a -> EntryCompletionActionActivatedCallback -> m SignalHandlerId+afterEntryCompletionActionActivated obj cb = connectEntryCompletionActionActivated obj cb SignalConnectAfter++connectEntryCompletionActionActivated :: (GObject a, MonadIO m) =>+                                         a -> EntryCompletionActionActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCompletionActionActivated obj cb after = liftIO $ do+    cb' <- mkEntryCompletionActionActivatedCallback (entryCompletionActionActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "action-activated" cb' after++-- signal EntryCompletion::cursor-on-match+type EntryCompletionCursorOnMatchCallback =+    TreeModel ->+    TreeIter ->+    IO Bool++noEntryCompletionCursorOnMatchCallback :: Maybe EntryCompletionCursorOnMatchCallback+noEntryCompletionCursorOnMatchCallback = Nothing++type EntryCompletionCursorOnMatchCallbackC =+    Ptr () ->                               -- object+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkEntryCompletionCursorOnMatchCallback :: EntryCompletionCursorOnMatchCallbackC -> IO (FunPtr EntryCompletionCursorOnMatchCallbackC)++entryCompletionCursorOnMatchClosure :: EntryCompletionCursorOnMatchCallback -> IO Closure+entryCompletionCursorOnMatchClosure cb = newCClosure =<< mkEntryCompletionCursorOnMatchCallback wrapped+    where wrapped = entryCompletionCursorOnMatchCallbackWrapper cb++entryCompletionCursorOnMatchCallbackWrapper ::+    EntryCompletionCursorOnMatchCallback ->+    Ptr () ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+entryCompletionCursorOnMatchCallbackWrapper _cb _ model iter _ = do+    model' <- (newObject TreeModel) model+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' iter'+    let result' = (fromIntegral . fromEnum) result+    return result'++onEntryCompletionCursorOnMatch :: (GObject a, MonadIO m) => a -> EntryCompletionCursorOnMatchCallback -> m SignalHandlerId+onEntryCompletionCursorOnMatch obj cb = liftIO $ connectEntryCompletionCursorOnMatch obj cb SignalConnectBefore+afterEntryCompletionCursorOnMatch :: (GObject a, MonadIO m) => a -> EntryCompletionCursorOnMatchCallback -> m SignalHandlerId+afterEntryCompletionCursorOnMatch obj cb = connectEntryCompletionCursorOnMatch obj cb SignalConnectAfter++connectEntryCompletionCursorOnMatch :: (GObject a, MonadIO m) =>+                                       a -> EntryCompletionCursorOnMatchCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCompletionCursorOnMatch obj cb after = liftIO $ do+    cb' <- mkEntryCompletionCursorOnMatchCallback (entryCompletionCursorOnMatchCallbackWrapper cb)+    connectSignalFunPtr obj "cursor-on-match" cb' after++-- signal EntryCompletion::insert-prefix+type EntryCompletionInsertPrefixCallback =+    T.Text ->+    IO Bool++noEntryCompletionInsertPrefixCallback :: Maybe EntryCompletionInsertPrefixCallback+noEntryCompletionInsertPrefixCallback = Nothing++type EntryCompletionInsertPrefixCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkEntryCompletionInsertPrefixCallback :: EntryCompletionInsertPrefixCallbackC -> IO (FunPtr EntryCompletionInsertPrefixCallbackC)++entryCompletionInsertPrefixClosure :: EntryCompletionInsertPrefixCallback -> IO Closure+entryCompletionInsertPrefixClosure cb = newCClosure =<< mkEntryCompletionInsertPrefixCallback wrapped+    where wrapped = entryCompletionInsertPrefixCallbackWrapper cb++entryCompletionInsertPrefixCallbackWrapper ::+    EntryCompletionInsertPrefixCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO CInt+entryCompletionInsertPrefixCallbackWrapper _cb _ prefix _ = do+    prefix' <- cstringToText prefix+    result <- _cb  prefix'+    let result' = (fromIntegral . fromEnum) result+    return result'++onEntryCompletionInsertPrefix :: (GObject a, MonadIO m) => a -> EntryCompletionInsertPrefixCallback -> m SignalHandlerId+onEntryCompletionInsertPrefix obj cb = liftIO $ connectEntryCompletionInsertPrefix obj cb SignalConnectBefore+afterEntryCompletionInsertPrefix :: (GObject a, MonadIO m) => a -> EntryCompletionInsertPrefixCallback -> m SignalHandlerId+afterEntryCompletionInsertPrefix obj cb = connectEntryCompletionInsertPrefix obj cb SignalConnectAfter++connectEntryCompletionInsertPrefix :: (GObject a, MonadIO m) =>+                                      a -> EntryCompletionInsertPrefixCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCompletionInsertPrefix obj cb after = liftIO $ do+    cb' <- mkEntryCompletionInsertPrefixCallback (entryCompletionInsertPrefixCallbackWrapper cb)+    connectSignalFunPtr obj "insert-prefix" cb' after++-- signal EntryCompletion::match-selected+type EntryCompletionMatchSelectedCallback =+    TreeModel ->+    TreeIter ->+    IO Bool++noEntryCompletionMatchSelectedCallback :: Maybe EntryCompletionMatchSelectedCallback+noEntryCompletionMatchSelectedCallback = Nothing++type EntryCompletionMatchSelectedCallbackC =+    Ptr () ->                               -- object+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkEntryCompletionMatchSelectedCallback :: EntryCompletionMatchSelectedCallbackC -> IO (FunPtr EntryCompletionMatchSelectedCallbackC)++entryCompletionMatchSelectedClosure :: EntryCompletionMatchSelectedCallback -> IO Closure+entryCompletionMatchSelectedClosure cb = newCClosure =<< mkEntryCompletionMatchSelectedCallback wrapped+    where wrapped = entryCompletionMatchSelectedCallbackWrapper cb++entryCompletionMatchSelectedCallbackWrapper ::+    EntryCompletionMatchSelectedCallback ->+    Ptr () ->+    Ptr TreeModel ->+    Ptr TreeIter ->+    Ptr () ->+    IO CInt+entryCompletionMatchSelectedCallbackWrapper _cb _ model iter _ = do+    model' <- (newObject TreeModel) model+    iter' <- (newBoxed TreeIter) iter+    result <- _cb  model' iter'+    let result' = (fromIntegral . fromEnum) result+    return result'++onEntryCompletionMatchSelected :: (GObject a, MonadIO m) => a -> EntryCompletionMatchSelectedCallback -> m SignalHandlerId+onEntryCompletionMatchSelected obj cb = liftIO $ connectEntryCompletionMatchSelected obj cb SignalConnectBefore+afterEntryCompletionMatchSelected :: (GObject a, MonadIO m) => a -> EntryCompletionMatchSelectedCallback -> m SignalHandlerId+afterEntryCompletionMatchSelected obj cb = connectEntryCompletionMatchSelected obj cb SignalConnectAfter++connectEntryCompletionMatchSelected :: (GObject a, MonadIO m) =>+                                       a -> EntryCompletionMatchSelectedCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCompletionMatchSelected obj cb after = liftIO $ do+    cb' <- mkEntryCompletionMatchSelectedCallback (entryCompletionMatchSelectedCallbackWrapper cb)+    connectSignalFunPtr obj "match-selected" cb' after++-- signal EntryCompletion::no-matches+type EntryCompletionNoMatchesCallback =+    IO ()++noEntryCompletionNoMatchesCallback :: Maybe EntryCompletionNoMatchesCallback+noEntryCompletionNoMatchesCallback = Nothing++type EntryCompletionNoMatchesCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkEntryCompletionNoMatchesCallback :: EntryCompletionNoMatchesCallbackC -> IO (FunPtr EntryCompletionNoMatchesCallbackC)++entryCompletionNoMatchesClosure :: EntryCompletionNoMatchesCallback -> IO Closure+entryCompletionNoMatchesClosure cb = newCClosure =<< mkEntryCompletionNoMatchesCallback wrapped+    where wrapped = entryCompletionNoMatchesCallbackWrapper cb++entryCompletionNoMatchesCallbackWrapper ::+    EntryCompletionNoMatchesCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+entryCompletionNoMatchesCallbackWrapper _cb _ _ = do+    _cb ++onEntryCompletionNoMatches :: (GObject a, MonadIO m) => a -> EntryCompletionNoMatchesCallback -> m SignalHandlerId+onEntryCompletionNoMatches obj cb = liftIO $ connectEntryCompletionNoMatches obj cb SignalConnectBefore+afterEntryCompletionNoMatches :: (GObject a, MonadIO m) => a -> EntryCompletionNoMatchesCallback -> m SignalHandlerId+afterEntryCompletionNoMatches obj cb = connectEntryCompletionNoMatches obj cb SignalConnectAfter++connectEntryCompletionNoMatches :: (GObject a, MonadIO m) =>+                                   a -> EntryCompletionNoMatchesCallback -> SignalConnectMode -> m SignalHandlerId+connectEntryCompletionNoMatches obj cb after = liftIO $ do+    cb' <- mkEntryCompletionNoMatchesCallback (entryCompletionNoMatchesCallbackWrapper cb)+    connectSignalFunPtr obj "no-matches" cb' after++-- VVV Prop "cell-area"+   -- Type: TInterface "Gtk" "CellArea"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getEntryCompletionCellArea :: (MonadIO m, EntryCompletionK o) => o -> m CellArea+getEntryCompletionCellArea obj = liftIO $ getObjectPropertyObject obj "cell-area" CellArea++constructEntryCompletionCellArea :: (CellAreaK a) => a -> IO ([Char], GValue)+constructEntryCompletionCellArea val = constructObjectPropertyObject "cell-area" val++data EntryCompletionCellAreaPropertyInfo+instance AttrInfo EntryCompletionCellAreaPropertyInfo where+    type AttrAllowedOps EntryCompletionCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionCellAreaPropertyInfo = CellAreaK+    type AttrBaseTypeConstraint EntryCompletionCellAreaPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionCellAreaPropertyInfo = CellArea+    type AttrLabel EntryCompletionCellAreaPropertyInfo = "EntryCompletion::cell-area"+    attrGet _ = getEntryCompletionCellArea+    attrSet _ = undefined+    attrConstruct _ = constructEntryCompletionCellArea++-- VVV Prop "inline-completion"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionInlineCompletion :: (MonadIO m, EntryCompletionK o) => o -> m Bool+getEntryCompletionInlineCompletion obj = liftIO $ getObjectPropertyBool obj "inline-completion"++setEntryCompletionInlineCompletion :: (MonadIO m, EntryCompletionK o) => o -> Bool -> m ()+setEntryCompletionInlineCompletion obj val = liftIO $ setObjectPropertyBool obj "inline-completion" val++constructEntryCompletionInlineCompletion :: Bool -> IO ([Char], GValue)+constructEntryCompletionInlineCompletion val = constructObjectPropertyBool "inline-completion" val++data EntryCompletionInlineCompletionPropertyInfo+instance AttrInfo EntryCompletionInlineCompletionPropertyInfo where+    type AttrAllowedOps EntryCompletionInlineCompletionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionInlineCompletionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCompletionInlineCompletionPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionInlineCompletionPropertyInfo = Bool+    type AttrLabel EntryCompletionInlineCompletionPropertyInfo = "EntryCompletion::inline-completion"+    attrGet _ = getEntryCompletionInlineCompletion+    attrSet _ = setEntryCompletionInlineCompletion+    attrConstruct _ = constructEntryCompletionInlineCompletion++-- VVV Prop "inline-selection"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionInlineSelection :: (MonadIO m, EntryCompletionK o) => o -> m Bool+getEntryCompletionInlineSelection obj = liftIO $ getObjectPropertyBool obj "inline-selection"++setEntryCompletionInlineSelection :: (MonadIO m, EntryCompletionK o) => o -> Bool -> m ()+setEntryCompletionInlineSelection obj val = liftIO $ setObjectPropertyBool obj "inline-selection" val++constructEntryCompletionInlineSelection :: Bool -> IO ([Char], GValue)+constructEntryCompletionInlineSelection val = constructObjectPropertyBool "inline-selection" val++data EntryCompletionInlineSelectionPropertyInfo+instance AttrInfo EntryCompletionInlineSelectionPropertyInfo where+    type AttrAllowedOps EntryCompletionInlineSelectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionInlineSelectionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCompletionInlineSelectionPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionInlineSelectionPropertyInfo = Bool+    type AttrLabel EntryCompletionInlineSelectionPropertyInfo = "EntryCompletion::inline-selection"+    attrGet _ = getEntryCompletionInlineSelection+    attrSet _ = setEntryCompletionInlineSelection+    attrConstruct _ = constructEntryCompletionInlineSelection++-- VVV Prop "minimum-key-length"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionMinimumKeyLength :: (MonadIO m, EntryCompletionK o) => o -> m Int32+getEntryCompletionMinimumKeyLength obj = liftIO $ getObjectPropertyCInt obj "minimum-key-length"++setEntryCompletionMinimumKeyLength :: (MonadIO m, EntryCompletionK o) => o -> Int32 -> m ()+setEntryCompletionMinimumKeyLength obj val = liftIO $ setObjectPropertyCInt obj "minimum-key-length" val++constructEntryCompletionMinimumKeyLength :: Int32 -> IO ([Char], GValue)+constructEntryCompletionMinimumKeyLength val = constructObjectPropertyCInt "minimum-key-length" val++data EntryCompletionMinimumKeyLengthPropertyInfo+instance AttrInfo EntryCompletionMinimumKeyLengthPropertyInfo where+    type AttrAllowedOps EntryCompletionMinimumKeyLengthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionMinimumKeyLengthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryCompletionMinimumKeyLengthPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionMinimumKeyLengthPropertyInfo = Int32+    type AttrLabel EntryCompletionMinimumKeyLengthPropertyInfo = "EntryCompletion::minimum-key-length"+    attrGet _ = getEntryCompletionMinimumKeyLength+    attrSet _ = setEntryCompletionMinimumKeyLength+    attrConstruct _ = constructEntryCompletionMinimumKeyLength++-- VVV Prop "model"+   -- Type: TInterface "Gtk" "TreeModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionModel :: (MonadIO m, EntryCompletionK o) => o -> m TreeModel+getEntryCompletionModel obj = liftIO $ getObjectPropertyObject obj "model" TreeModel++setEntryCompletionModel :: (MonadIO m, EntryCompletionK o, TreeModelK a) => o -> a -> m ()+setEntryCompletionModel obj val = liftIO $ setObjectPropertyObject obj "model" val++constructEntryCompletionModel :: (TreeModelK a) => a -> IO ([Char], GValue)+constructEntryCompletionModel val = constructObjectPropertyObject "model" val++data EntryCompletionModelPropertyInfo+instance AttrInfo EntryCompletionModelPropertyInfo where+    type AttrAllowedOps EntryCompletionModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionModelPropertyInfo = TreeModelK+    type AttrBaseTypeConstraint EntryCompletionModelPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionModelPropertyInfo = TreeModel+    type AttrLabel EntryCompletionModelPropertyInfo = "EntryCompletion::model"+    attrGet _ = getEntryCompletionModel+    attrSet _ = setEntryCompletionModel+    attrConstruct _ = constructEntryCompletionModel++-- VVV Prop "popup-completion"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionPopupCompletion :: (MonadIO m, EntryCompletionK o) => o -> m Bool+getEntryCompletionPopupCompletion obj = liftIO $ getObjectPropertyBool obj "popup-completion"++setEntryCompletionPopupCompletion :: (MonadIO m, EntryCompletionK o) => o -> Bool -> m ()+setEntryCompletionPopupCompletion obj val = liftIO $ setObjectPropertyBool obj "popup-completion" val++constructEntryCompletionPopupCompletion :: Bool -> IO ([Char], GValue)+constructEntryCompletionPopupCompletion val = constructObjectPropertyBool "popup-completion" val++data EntryCompletionPopupCompletionPropertyInfo+instance AttrInfo EntryCompletionPopupCompletionPropertyInfo where+    type AttrAllowedOps EntryCompletionPopupCompletionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionPopupCompletionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCompletionPopupCompletionPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionPopupCompletionPropertyInfo = Bool+    type AttrLabel EntryCompletionPopupCompletionPropertyInfo = "EntryCompletion::popup-completion"+    attrGet _ = getEntryCompletionPopupCompletion+    attrSet _ = setEntryCompletionPopupCompletion+    attrConstruct _ = constructEntryCompletionPopupCompletion++-- VVV Prop "popup-set-width"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionPopupSetWidth :: (MonadIO m, EntryCompletionK o) => o -> m Bool+getEntryCompletionPopupSetWidth obj = liftIO $ getObjectPropertyBool obj "popup-set-width"++setEntryCompletionPopupSetWidth :: (MonadIO m, EntryCompletionK o) => o -> Bool -> m ()+setEntryCompletionPopupSetWidth obj val = liftIO $ setObjectPropertyBool obj "popup-set-width" val++constructEntryCompletionPopupSetWidth :: Bool -> IO ([Char], GValue)+constructEntryCompletionPopupSetWidth val = constructObjectPropertyBool "popup-set-width" val++data EntryCompletionPopupSetWidthPropertyInfo+instance AttrInfo EntryCompletionPopupSetWidthPropertyInfo where+    type AttrAllowedOps EntryCompletionPopupSetWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionPopupSetWidthPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCompletionPopupSetWidthPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionPopupSetWidthPropertyInfo = Bool+    type AttrLabel EntryCompletionPopupSetWidthPropertyInfo = "EntryCompletion::popup-set-width"+    attrGet _ = getEntryCompletionPopupSetWidth+    attrSet _ = setEntryCompletionPopupSetWidth+    attrConstruct _ = constructEntryCompletionPopupSetWidth++-- VVV Prop "popup-single-match"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionPopupSingleMatch :: (MonadIO m, EntryCompletionK o) => o -> m Bool+getEntryCompletionPopupSingleMatch obj = liftIO $ getObjectPropertyBool obj "popup-single-match"++setEntryCompletionPopupSingleMatch :: (MonadIO m, EntryCompletionK o) => o -> Bool -> m ()+setEntryCompletionPopupSingleMatch obj val = liftIO $ setObjectPropertyBool obj "popup-single-match" val++constructEntryCompletionPopupSingleMatch :: Bool -> IO ([Char], GValue)+constructEntryCompletionPopupSingleMatch val = constructObjectPropertyBool "popup-single-match" val++data EntryCompletionPopupSingleMatchPropertyInfo+instance AttrInfo EntryCompletionPopupSingleMatchPropertyInfo where+    type AttrAllowedOps EntryCompletionPopupSingleMatchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionPopupSingleMatchPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EntryCompletionPopupSingleMatchPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionPopupSingleMatchPropertyInfo = Bool+    type AttrLabel EntryCompletionPopupSingleMatchPropertyInfo = "EntryCompletion::popup-single-match"+    attrGet _ = getEntryCompletionPopupSingleMatch+    attrSet _ = setEntryCompletionPopupSingleMatch+    attrConstruct _ = constructEntryCompletionPopupSingleMatch++-- VVV Prop "text-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getEntryCompletionTextColumn :: (MonadIO m, EntryCompletionK o) => o -> m Int32+getEntryCompletionTextColumn obj = liftIO $ getObjectPropertyCInt obj "text-column"++setEntryCompletionTextColumn :: (MonadIO m, EntryCompletionK o) => o -> Int32 -> m ()+setEntryCompletionTextColumn obj val = liftIO $ setObjectPropertyCInt obj "text-column" val++constructEntryCompletionTextColumn :: Int32 -> IO ([Char], GValue)+constructEntryCompletionTextColumn val = constructObjectPropertyCInt "text-column" val++data EntryCompletionTextColumnPropertyInfo+instance AttrInfo EntryCompletionTextColumnPropertyInfo where+    type AttrAllowedOps EntryCompletionTextColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EntryCompletionTextColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint EntryCompletionTextColumnPropertyInfo = EntryCompletionK+    type AttrGetType EntryCompletionTextColumnPropertyInfo = Int32+    type AttrLabel EntryCompletionTextColumnPropertyInfo = "EntryCompletion::text-column"+    attrGet _ = getEntryCompletionTextColumn+    attrSet _ = setEntryCompletionTextColumn+    attrConstruct _ = constructEntryCompletionTextColumn++type instance AttributeList EntryCompletion = EntryCompletionAttributeList+type EntryCompletionAttributeList = ('[ '("cell-area", EntryCompletionCellAreaPropertyInfo), '("inline-completion", EntryCompletionInlineCompletionPropertyInfo), '("inline-selection", EntryCompletionInlineSelectionPropertyInfo), '("minimum-key-length", EntryCompletionMinimumKeyLengthPropertyInfo), '("model", EntryCompletionModelPropertyInfo), '("popup-completion", EntryCompletionPopupCompletionPropertyInfo), '("popup-set-width", EntryCompletionPopupSetWidthPropertyInfo), '("popup-single-match", EntryCompletionPopupSingleMatchPropertyInfo), '("text-column", EntryCompletionTextColumnPropertyInfo)] :: [(Symbol, *)])++data EntryCompletionActionActivatedSignalInfo+instance SignalInfo EntryCompletionActionActivatedSignalInfo where+    type HaskellCallbackType EntryCompletionActionActivatedSignalInfo = EntryCompletionActionActivatedCallback+    connectSignal _ = connectEntryCompletionActionActivated++data EntryCompletionCursorOnMatchSignalInfo+instance SignalInfo EntryCompletionCursorOnMatchSignalInfo where+    type HaskellCallbackType EntryCompletionCursorOnMatchSignalInfo = EntryCompletionCursorOnMatchCallback+    connectSignal _ = connectEntryCompletionCursorOnMatch++data EntryCompletionInsertPrefixSignalInfo+instance SignalInfo EntryCompletionInsertPrefixSignalInfo where+    type HaskellCallbackType EntryCompletionInsertPrefixSignalInfo = EntryCompletionInsertPrefixCallback+    connectSignal _ = connectEntryCompletionInsertPrefix++data EntryCompletionMatchSelectedSignalInfo+instance SignalInfo EntryCompletionMatchSelectedSignalInfo where+    type HaskellCallbackType EntryCompletionMatchSelectedSignalInfo = EntryCompletionMatchSelectedCallback+    connectSignal _ = connectEntryCompletionMatchSelected++data EntryCompletionNoMatchesSignalInfo+instance SignalInfo EntryCompletionNoMatchesSignalInfo where+    type HaskellCallbackType EntryCompletionNoMatchesSignalInfo = EntryCompletionNoMatchesCallback+    connectSignal _ = connectEntryCompletionNoMatches++type instance SignalList EntryCompletion = EntryCompletionSignalList+type EntryCompletionSignalList = ('[ '("action-activated", EntryCompletionActionActivatedSignalInfo), '("cursor-on-match", EntryCompletionCursorOnMatchSignalInfo), '("insert-prefix", EntryCompletionInsertPrefixSignalInfo), '("match-selected", EntryCompletionMatchSelectedSignalInfo), '("no-matches", EntryCompletionNoMatchesSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method EntryCompletion::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "EntryCompletion"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_new" gtk_entry_completion_new :: +    IO (Ptr EntryCompletion)+++entryCompletionNew ::+    (MonadIO m) =>+    m EntryCompletion+entryCompletionNew  = liftIO $ do+    result <- gtk_entry_completion_new+    checkUnexpectedReturnNULL "gtk_entry_completion_new" result+    result' <- (wrapObject EntryCompletion) result+    return result'++-- method EntryCompletion::new_with_area+-- method type : Constructor+-- Args : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "EntryCompletion"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_new_with_area" gtk_entry_completion_new_with_area :: +    Ptr CellArea ->                         -- area : TInterface "Gtk" "CellArea"+    IO (Ptr EntryCompletion)+++entryCompletionNewWithArea ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- area+    m EntryCompletion+entryCompletionNewWithArea area = liftIO $ do+    let area' = unsafeManagedPtrCastPtr area+    result <- gtk_entry_completion_new_with_area area'+    checkUnexpectedReturnNULL "gtk_entry_completion_new_with_area" result+    result' <- (wrapObject EntryCompletion) result+    touchManagedPtr area+    return result'++-- method EntryCompletion::complete+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_complete" gtk_entry_completion_complete :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO ()+++entryCompletionComplete ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m ()+entryCompletionComplete _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_completion_complete _obj'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::compute_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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 "Gtk" "EntryCompletion", 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 "gtk_entry_completion_compute_prefix" gtk_entry_completion_compute_prefix :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++entryCompletionComputePrefix ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m T.Text+entryCompletionComputePrefix _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_entry_completion_compute_prefix _obj' key'+    checkUnexpectedReturnNULL "gtk_entry_completion_compute_prefix" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method EntryCompletion::delete_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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 "Gtk" "EntryCompletion", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_delete_action" gtk_entry_completion_delete_action :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Int32 ->                                -- index_ : TBasicType TInt32+    IO ()+++entryCompletionDeleteAction ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    m ()+entryCompletionDeleteAction _obj index_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_completion_delete_action _obj' index_+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::get_completion_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_completion_prefix" gtk_entry_completion_get_completion_prefix :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CString+++entryCompletionGetCompletionPrefix ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m T.Text+entryCompletionGetCompletionPrefix _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_completion_prefix _obj'+    checkUnexpectedReturnNULL "gtk_entry_completion_get_completion_prefix" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_entry" gtk_entry_completion_get_entry :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO (Ptr Widget)+++entryCompletionGetEntry ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Widget+entryCompletionGetEntry _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_entry _obj'+    checkUnexpectedReturnNULL "gtk_entry_completion_get_entry" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_inline_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_inline_completion" gtk_entry_completion_get_inline_completion :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CInt+++entryCompletionGetInlineCompletion ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Bool+entryCompletionGetInlineCompletion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_inline_completion _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_inline_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_inline_selection" gtk_entry_completion_get_inline_selection :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CInt+++entryCompletionGetInlineSelection ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Bool+entryCompletionGetInlineSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_inline_selection _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_minimum_key_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_minimum_key_length" gtk_entry_completion_get_minimum_key_length :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO Int32+++entryCompletionGetMinimumKeyLength ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Int32+entryCompletionGetMinimumKeyLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_minimum_key_length _obj'+    touchManagedPtr _obj+    return result++-- method EntryCompletion::get_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_model" gtk_entry_completion_get_model :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO (Ptr TreeModel)+++entryCompletionGetModel ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m TreeModel+entryCompletionGetModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_model _obj'+    checkUnexpectedReturnNULL "gtk_entry_completion_get_model" result+    result' <- (newObject TreeModel) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_popup_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_popup_completion" gtk_entry_completion_get_popup_completion :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CInt+++entryCompletionGetPopupCompletion ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Bool+entryCompletionGetPopupCompletion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_popup_completion _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_popup_set_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_popup_set_width" gtk_entry_completion_get_popup_set_width :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CInt+++entryCompletionGetPopupSetWidth ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Bool+entryCompletionGetPopupSetWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_popup_set_width _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_popup_single_match+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_popup_single_match" gtk_entry_completion_get_popup_single_match :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO CInt+++entryCompletionGetPopupSingleMatch ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Bool+entryCompletionGetPopupSingleMatch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_popup_single_match _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EntryCompletion::get_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_get_text_column" gtk_entry_completion_get_text_column :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO Int32+++entryCompletionGetTextColumn ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m Int32+entryCompletionGetTextColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_entry_completion_get_text_column _obj'+    touchManagedPtr _obj+    return result++-- method EntryCompletion::insert_action_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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},Arg {argName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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},Arg {argName = "markup", 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 "gtk_entry_completion_insert_action_markup" gtk_entry_completion_insert_action_markup :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Int32 ->                                -- index_ : TBasicType TInt32+    CString ->                              -- markup : TBasicType TUTF8+    IO ()+++entryCompletionInsertActionMarkup ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    T.Text ->                               -- markup+    m ()+entryCompletionInsertActionMarkup _obj index_ markup = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    markup' <- textToCString markup+    gtk_entry_completion_insert_action_markup _obj' index_ markup'+    touchManagedPtr _obj+    freeMem markup'+    return ()++-- method EntryCompletion::insert_action_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", 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},Arg {argName = "text", 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 "gtk_entry_completion_insert_action_text" gtk_entry_completion_insert_action_text :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Int32 ->                                -- index_ : TBasicType TInt32+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++entryCompletionInsertActionText ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    T.Text ->                               -- text+    m ()+entryCompletionInsertActionText _obj index_ text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_entry_completion_insert_action_text _obj' index_ text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method EntryCompletion::insert_prefix+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_insert_prefix" gtk_entry_completion_insert_prefix :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    IO ()+++entryCompletionInsertPrefix ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    m ()+entryCompletionInsertPrefix _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_completion_insert_prefix _obj'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_inline_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inline_completion", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inline_completion", 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 "gtk_entry_completion_set_inline_completion" gtk_entry_completion_set_inline_completion :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CInt ->                                 -- inline_completion : TBasicType TBoolean+    IO ()+++entryCompletionSetInlineCompletion ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- inline_completion+    m ()+entryCompletionSetInlineCompletion _obj inline_completion = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let inline_completion' = (fromIntegral . fromEnum) inline_completion+    gtk_entry_completion_set_inline_completion _obj' inline_completion'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_inline_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inline_selection", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "inline_selection", 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 "gtk_entry_completion_set_inline_selection" gtk_entry_completion_set_inline_selection :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CInt ->                                 -- inline_selection : TBasicType TBoolean+    IO ()+++entryCompletionSetInlineSelection ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- inline_selection+    m ()+entryCompletionSetInlineSelection _obj inline_selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let inline_selection' = (fromIntegral . fromEnum) inline_selection+    gtk_entry_completion_set_inline_selection _obj' inline_selection'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_match_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "EntryCompletionMatchFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing},Arg {argName = "func_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "EntryCompletionMatchFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_set_match_func" gtk_entry_completion_set_match_func :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    FunPtr EntryCompletionMatchFuncC ->     -- func : TInterface "Gtk" "EntryCompletionMatchFunc"+    Ptr () ->                               -- func_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- func_notify : TInterface "GLib" "DestroyNotify"+    IO ()+++entryCompletionSetMatchFunc ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    EntryCompletionMatchFunc ->             -- func+    m ()+entryCompletionSetMatchFunc _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkEntryCompletionMatchFunc (entryCompletionMatchFuncWrapper Nothing func)+    let func_data = castFunPtrToPtr func'+    let func_notify = safeFreeFunPtrPtr+    gtk_entry_completion_set_match_func _obj' func' func_data func_notify+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_minimum_key_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", 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 "gtk_entry_completion_set_minimum_key_length" gtk_entry_completion_set_minimum_key_length :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Int32 ->                                -- length : TBasicType TInt32+    IO ()+++entryCompletionSetMinimumKeyLength ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- length+    m ()+entryCompletionSetMinimumKeyLength _obj length_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_completion_set_minimum_key_length _obj' length_+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_entry_completion_set_model" gtk_entry_completion_set_model :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO ()+++entryCompletionSetModel ::+    (MonadIO m, EntryCompletionK a, TreeModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    m ()+entryCompletionSetModel _obj model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    gtk_entry_completion_set_model _obj' maybeModel+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    return ()++-- method EntryCompletion::set_popup_completion+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_completion", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_completion", 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 "gtk_entry_completion_set_popup_completion" gtk_entry_completion_set_popup_completion :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CInt ->                                 -- popup_completion : TBasicType TBoolean+    IO ()+++entryCompletionSetPopupCompletion ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- popup_completion+    m ()+entryCompletionSetPopupCompletion _obj popup_completion = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let popup_completion' = (fromIntegral . fromEnum) popup_completion+    gtk_entry_completion_set_popup_completion _obj' popup_completion'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_popup_set_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_set_width", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_set_width", 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 "gtk_entry_completion_set_popup_set_width" gtk_entry_completion_set_popup_set_width :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CInt ->                                 -- popup_set_width : TBasicType TBoolean+    IO ()+++entryCompletionSetPopupSetWidth ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- popup_set_width+    m ()+entryCompletionSetPopupSetWidth _obj popup_set_width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let popup_set_width' = (fromIntegral . fromEnum) popup_set_width+    gtk_entry_completion_set_popup_set_width _obj' popup_set_width'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_popup_single_match+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_single_match", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_single_match", 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 "gtk_entry_completion_set_popup_single_match" gtk_entry_completion_set_popup_single_match :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    CInt ->                                 -- popup_single_match : TBasicType TBoolean+    IO ()+++entryCompletionSetPopupSingleMatch ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- popup_single_match+    m ()+entryCompletionSetPopupSingleMatch _obj popup_single_match = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let popup_single_match' = (fromIntegral . fromEnum) popup_single_match+    gtk_entry_completion_set_popup_single_match _obj' popup_single_match'+    touchManagedPtr _obj+    return ()++-- method EntryCompletion::set_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EntryCompletion", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_entry_completion_set_text_column" gtk_entry_completion_set_text_column :: +    Ptr EntryCompletion ->                  -- _obj : TInterface "Gtk" "EntryCompletion"+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++entryCompletionSetTextColumn ::+    (MonadIO m, EntryCompletionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column+    m ()+entryCompletionSetTextColumn _obj column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_entry_completion_set_text_column _obj' column+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/EntryCompletion.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gtk.Objects.EntryCompletion where++import Prelude ()+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 EntryCompletion = EntryCompletion (ForeignPtr EntryCompletion)+instance GObject EntryCompletion where+class GObject o => EntryCompletionK o+instance (GObject o, IsDescendantOf EntryCompletion o) => EntryCompletionK o+data EntryCompletionCellAreaPropertyInfo+data EntryCompletionInlineCompletionPropertyInfo+data EntryCompletionInlineSelectionPropertyInfo+data EntryCompletionMinimumKeyLengthPropertyInfo+data EntryCompletionModelPropertyInfo+data EntryCompletionPopupCompletionPropertyInfo+data EntryCompletionPopupSetWidthPropertyInfo+data EntryCompletionPopupSingleMatchPropertyInfo+data EntryCompletionTextColumnPropertyInfo+data EntryCompletionActionActivatedSignalInfo+data EntryCompletionCursorOnMatchSignalInfo+data EntryCompletionInsertPrefixSignalInfo+data EntryCompletionMatchSelectedSignalInfo+data EntryCompletionNoMatchesSignalInfo
+ GI/Gtk/Objects/EntryIconAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.EntryIconAccessible+    ( ++-- * Exported types+    EntryIconAccessible(..)                 ,+    EntryIconAccessibleK                    ,+    toEntryIconAccessible                   ,+    noEntryIconAccessible                   ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype EntryIconAccessible = EntryIconAccessible (ForeignPtr EntryIconAccessible)+foreign import ccall "gtk_entry_icon_accessible_get_type"+    c_gtk_entry_icon_accessible_get_type :: IO GType++type instance ParentTypes EntryIconAccessible = EntryIconAccessibleParentTypes+type EntryIconAccessibleParentTypes = '[Atk.Object, GObject.Object, Atk.Action, Atk.Component]++instance GObject EntryIconAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_entry_icon_accessible_get_type+    ++class GObject o => EntryIconAccessibleK o+instance (GObject o, IsDescendantOf EntryIconAccessible o) => EntryIconAccessibleK o++toEntryIconAccessible :: EntryIconAccessibleK o => o -> IO EntryIconAccessible+toEntryIconAccessible = unsafeCastTo EntryIconAccessible++noEntryIconAccessible :: Maybe EntryIconAccessible+noEntryIconAccessible = Nothing++type instance AttributeList EntryIconAccessible = EntryIconAccessibleAttributeList+type EntryIconAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo)] :: [(Symbol, *)])++type instance SignalList EntryIconAccessible = EntryIconAccessibleSignalList+type EntryIconAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/EntryIconAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.EntryIconAccessible where++import Prelude ()+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 EntryIconAccessible = EntryIconAccessible (ForeignPtr EntryIconAccessible)+instance GObject EntryIconAccessible where+class GObject o => EntryIconAccessibleK o+instance (GObject o, IsDescendantOf EntryIconAccessible o) => EntryIconAccessibleK o
+ GI/Gtk/Objects/EventBox.hs view
@@ -0,0 +1,273 @@++{- |+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.Gtk.Objects.EventBox+    ( ++-- * Exported types+    EventBox(..)                            ,+    EventBoxK                               ,+    toEventBox                              ,+    noEventBox                              ,+++ -- * Methods+-- ** eventBoxGetAboveChild+    eventBoxGetAboveChild                   ,+++-- ** eventBoxGetVisibleWindow+    eventBoxGetVisibleWindow                ,+++-- ** eventBoxNew+    eventBoxNew                             ,+++-- ** eventBoxSetAboveChild+    eventBoxSetAboveChild                   ,+++-- ** eventBoxSetVisibleWindow+    eventBoxSetVisibleWindow                ,+++++ -- * Properties+-- ** AboveChild+    EventBoxAboveChildPropertyInfo          ,+    constructEventBoxAboveChild             ,+    getEventBoxAboveChild                   ,+    setEventBoxAboveChild                   ,+++-- ** VisibleWindow+    EventBoxVisibleWindowPropertyInfo       ,+    constructEventBoxVisibleWindow          ,+    getEventBoxVisibleWindow                ,+    setEventBoxVisibleWindow                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype EventBox = EventBox (ForeignPtr EventBox)+foreign import ccall "gtk_event_box_get_type"+    c_gtk_event_box_get_type :: IO GType++type instance ParentTypes EventBox = EventBoxParentTypes+type EventBoxParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject EventBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_event_box_get_type+    ++class GObject o => EventBoxK o+instance (GObject o, IsDescendantOf EventBox o) => EventBoxK o++toEventBox :: EventBoxK o => o -> IO EventBox+toEventBox = unsafeCastTo EventBox++noEventBox :: Maybe EventBox+noEventBox = Nothing++-- VVV Prop "above-child"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEventBoxAboveChild :: (MonadIO m, EventBoxK o) => o -> m Bool+getEventBoxAboveChild obj = liftIO $ getObjectPropertyBool obj "above-child"++setEventBoxAboveChild :: (MonadIO m, EventBoxK o) => o -> Bool -> m ()+setEventBoxAboveChild obj val = liftIO $ setObjectPropertyBool obj "above-child" val++constructEventBoxAboveChild :: Bool -> IO ([Char], GValue)+constructEventBoxAboveChild val = constructObjectPropertyBool "above-child" val++data EventBoxAboveChildPropertyInfo+instance AttrInfo EventBoxAboveChildPropertyInfo where+    type AttrAllowedOps EventBoxAboveChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EventBoxAboveChildPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EventBoxAboveChildPropertyInfo = EventBoxK+    type AttrGetType EventBoxAboveChildPropertyInfo = Bool+    type AttrLabel EventBoxAboveChildPropertyInfo = "EventBox::above-child"+    attrGet _ = getEventBoxAboveChild+    attrSet _ = setEventBoxAboveChild+    attrConstruct _ = constructEventBoxAboveChild++-- VVV Prop "visible-window"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getEventBoxVisibleWindow :: (MonadIO m, EventBoxK o) => o -> m Bool+getEventBoxVisibleWindow obj = liftIO $ getObjectPropertyBool obj "visible-window"++setEventBoxVisibleWindow :: (MonadIO m, EventBoxK o) => o -> Bool -> m ()+setEventBoxVisibleWindow obj val = liftIO $ setObjectPropertyBool obj "visible-window" val++constructEventBoxVisibleWindow :: Bool -> IO ([Char], GValue)+constructEventBoxVisibleWindow val = constructObjectPropertyBool "visible-window" val++data EventBoxVisibleWindowPropertyInfo+instance AttrInfo EventBoxVisibleWindowPropertyInfo where+    type AttrAllowedOps EventBoxVisibleWindowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EventBoxVisibleWindowPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint EventBoxVisibleWindowPropertyInfo = EventBoxK+    type AttrGetType EventBoxVisibleWindowPropertyInfo = Bool+    type AttrLabel EventBoxVisibleWindowPropertyInfo = "EventBox::visible-window"+    attrGet _ = getEventBoxVisibleWindow+    attrSet _ = setEventBoxVisibleWindow+    attrConstruct _ = constructEventBoxVisibleWindow++type instance AttributeList EventBox = EventBoxAttributeList+type EventBoxAttributeList = ('[ '("above-child", EventBoxAboveChildPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("visible-window", EventBoxVisibleWindowPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList EventBox = EventBoxSignalList+type EventBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method EventBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "EventBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_box_new" gtk_event_box_new :: +    IO (Ptr EventBox)+++eventBoxNew ::+    (MonadIO m) =>+    m EventBox+eventBoxNew  = liftIO $ do+    result <- gtk_event_box_new+    checkUnexpectedReturnNULL "gtk_event_box_new" result+    result' <- (newObject EventBox) result+    return result'++-- method EventBox::get_above_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_box_get_above_child" gtk_event_box_get_above_child :: +    Ptr EventBox ->                         -- _obj : TInterface "Gtk" "EventBox"+    IO CInt+++eventBoxGetAboveChild ::+    (MonadIO m, EventBoxK a) =>+    a ->                                    -- _obj+    m Bool+eventBoxGetAboveChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_event_box_get_above_child _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EventBox::get_visible_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_box_get_visible_window" gtk_event_box_get_visible_window :: +    Ptr EventBox ->                         -- _obj : TInterface "Gtk" "EventBox"+    IO CInt+++eventBoxGetVisibleWindow ::+    (MonadIO m, EventBoxK a) =>+    a ->                                    -- _obj+    m Bool+eventBoxGetVisibleWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_event_box_get_visible_window _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method EventBox::set_above_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "above_child", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "above_child", 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 "gtk_event_box_set_above_child" gtk_event_box_set_above_child :: +    Ptr EventBox ->                         -- _obj : TInterface "Gtk" "EventBox"+    CInt ->                                 -- above_child : TBasicType TBoolean+    IO ()+++eventBoxSetAboveChild ::+    (MonadIO m, EventBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- above_child+    m ()+eventBoxSetAboveChild _obj above_child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let above_child' = (fromIntegral . fromEnum) above_child+    gtk_event_box_set_above_child _obj' above_child'+    touchManagedPtr _obj+    return ()++-- method EventBox::set_visible_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_window", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible_window", 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 "gtk_event_box_set_visible_window" gtk_event_box_set_visible_window :: +    Ptr EventBox ->                         -- _obj : TInterface "Gtk" "EventBox"+    CInt ->                                 -- visible_window : TBasicType TBoolean+    IO ()+++eventBoxSetVisibleWindow ::+    (MonadIO m, EventBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible_window+    m ()+eventBoxSetVisibleWindow _obj visible_window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible_window' = (fromIntegral . fromEnum) visible_window+    gtk_event_box_set_visible_window _obj' visible_window'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/EventBox.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.EventBox where++import Prelude ()+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 EventBox = EventBox (ForeignPtr EventBox)+instance GObject EventBox where+class GObject o => EventBoxK o+instance (GObject o, IsDescendantOf EventBox o) => EventBoxK o+data EventBoxAboveChildPropertyInfo+data EventBoxVisibleWindowPropertyInfo
+ GI/Gtk/Objects/EventController.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.Gtk.Objects.EventController+    ( ++-- * Exported types+    EventController(..)                     ,+    EventControllerK                        ,+    toEventController                       ,+    noEventController                       ,+++ -- * Methods+-- ** eventControllerGetPropagationPhase+    eventControllerGetPropagationPhase      ,+++-- ** eventControllerGetWidget+    eventControllerGetWidget                ,+++-- ** eventControllerHandleEvent+    eventControllerHandleEvent              ,+++-- ** eventControllerReset+    eventControllerReset                    ,+++-- ** eventControllerSetPropagationPhase+    eventControllerSetPropagationPhase      ,+++++ -- * Properties+-- ** PropagationPhase+    EventControllerPropagationPhasePropertyInfo,+    constructEventControllerPropagationPhase,+    getEventControllerPropagationPhase      ,+    setEventControllerPropagationPhase      ,+++-- ** Widget+    EventControllerWidgetPropertyInfo       ,+    constructEventControllerWidget          ,+    getEventControllerWidget                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype EventController = EventController (ForeignPtr EventController)+foreign import ccall "gtk_event_controller_get_type"+    c_gtk_event_controller_get_type :: IO GType++type instance ParentTypes EventController = EventControllerParentTypes+type EventControllerParentTypes = '[GObject.Object]++instance GObject EventController where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_event_controller_get_type+    ++class GObject o => EventControllerK o+instance (GObject o, IsDescendantOf EventController o) => EventControllerK o++toEventController :: EventControllerK o => o -> IO EventController+toEventController = unsafeCastTo EventController++noEventController :: Maybe EventController+noEventController = Nothing++-- VVV Prop "propagation-phase"+   -- Type: TInterface "Gtk" "PropagationPhase"+   -- Flags: [PropertyReadable,PropertyWritable]++getEventControllerPropagationPhase :: (MonadIO m, EventControllerK o) => o -> m PropagationPhase+getEventControllerPropagationPhase obj = liftIO $ getObjectPropertyEnum obj "propagation-phase"++setEventControllerPropagationPhase :: (MonadIO m, EventControllerK o) => o -> PropagationPhase -> m ()+setEventControllerPropagationPhase obj val = liftIO $ setObjectPropertyEnum obj "propagation-phase" val++constructEventControllerPropagationPhase :: PropagationPhase -> IO ([Char], GValue)+constructEventControllerPropagationPhase val = constructObjectPropertyEnum "propagation-phase" val++data EventControllerPropagationPhasePropertyInfo+instance AttrInfo EventControllerPropagationPhasePropertyInfo where+    type AttrAllowedOps EventControllerPropagationPhasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EventControllerPropagationPhasePropertyInfo = (~) PropagationPhase+    type AttrBaseTypeConstraint EventControllerPropagationPhasePropertyInfo = EventControllerK+    type AttrGetType EventControllerPropagationPhasePropertyInfo = PropagationPhase+    type AttrLabel EventControllerPropagationPhasePropertyInfo = "EventController::propagation-phase"+    attrGet _ = getEventControllerPropagationPhase+    attrSet _ = setEventControllerPropagationPhase+    attrConstruct _ = constructEventControllerPropagationPhase++-- VVV Prop "widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getEventControllerWidget :: (MonadIO m, EventControllerK o) => o -> m Widget+getEventControllerWidget obj = liftIO $ getObjectPropertyObject obj "widget" Widget++constructEventControllerWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructEventControllerWidget val = constructObjectPropertyObject "widget" val++data EventControllerWidgetPropertyInfo+instance AttrInfo EventControllerWidgetPropertyInfo where+    type AttrAllowedOps EventControllerWidgetPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint EventControllerWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint EventControllerWidgetPropertyInfo = EventControllerK+    type AttrGetType EventControllerWidgetPropertyInfo = Widget+    type AttrLabel EventControllerWidgetPropertyInfo = "EventController::widget"+    attrGet _ = getEventControllerWidget+    attrSet _ = undefined+    attrConstruct _ = constructEventControllerWidget++type instance AttributeList EventController = EventControllerAttributeList+type EventControllerAttributeList = ('[ '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList EventController = EventControllerSignalList+type EventControllerSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method EventController::get_propagation_phase+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PropagationPhase"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_controller_get_propagation_phase" gtk_event_controller_get_propagation_phase :: +    Ptr EventController ->                  -- _obj : TInterface "Gtk" "EventController"+    IO CUInt+++eventControllerGetPropagationPhase ::+    (MonadIO m, EventControllerK a) =>+    a ->                                    -- _obj+    m PropagationPhase+eventControllerGetPropagationPhase _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_event_controller_get_propagation_phase _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method EventController::get_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_controller_get_widget" gtk_event_controller_get_widget :: +    Ptr EventController ->                  -- _obj : TInterface "Gtk" "EventController"+    IO (Ptr Widget)+++eventControllerGetWidget ::+    (MonadIO m, EventControllerK a) =>+    a ->                                    -- _obj+    m Widget+eventControllerGetWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_event_controller_get_widget _obj'+    checkUnexpectedReturnNULL "gtk_event_controller_get_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method EventController::handle_event+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_controller_handle_event" gtk_event_controller_handle_event :: +    Ptr EventController ->                  -- _obj : TInterface "Gtk" "EventController"+    Ptr Gdk.Event ->                        -- event : TInterface "Gdk" "Event"+    IO CInt+++eventControllerHandleEvent ::+    (MonadIO m, EventControllerK a) =>+    a ->                                    -- _obj+    Gdk.Event ->                            -- event+    m Bool+eventControllerHandleEvent _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    result <- gtk_event_controller_handle_event _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++-- method EventController::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_controller_reset" gtk_event_controller_reset :: +    Ptr EventController ->                  -- _obj : TInterface "Gtk" "EventController"+    IO ()+++eventControllerReset ::+    (MonadIO m, EventControllerK a) =>+    a ->                                    -- _obj+    m ()+eventControllerReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_event_controller_reset _obj'+    touchManagedPtr _obj+    return ()++-- method EventController::set_propagation_phase+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "phase", argType = TInterface "Gtk" "PropagationPhase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "EventController", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "phase", argType = TInterface "Gtk" "PropagationPhase", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_event_controller_set_propagation_phase" gtk_event_controller_set_propagation_phase :: +    Ptr EventController ->                  -- _obj : TInterface "Gtk" "EventController"+    CUInt ->                                -- phase : TInterface "Gtk" "PropagationPhase"+    IO ()+++eventControllerSetPropagationPhase ::+    (MonadIO m, EventControllerK a) =>+    a ->                                    -- _obj+    PropagationPhase ->                     -- phase+    m ()+eventControllerSetPropagationPhase _obj phase = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let phase' = (fromIntegral . fromEnum) phase+    gtk_event_controller_set_propagation_phase _obj' phase'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/EventController.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.EventController where++import Prelude ()+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 EventController = EventController (ForeignPtr EventController)+instance GObject EventController where+class GObject o => EventControllerK o+instance (GObject o, IsDescendantOf EventController o) => EventControllerK o+data EventControllerPropagationPhasePropertyInfo+data EventControllerWidgetPropertyInfo
+ GI/Gtk/Objects/Expander.hs view
@@ -0,0 +1,925 @@++{- |+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.Gtk.Objects.Expander+    ( ++-- * Exported types+    Expander(..)                            ,+    ExpanderK                               ,+    toExpander                              ,+    noExpander                              ,+++ -- * Methods+-- ** expanderGetExpanded+    expanderGetExpanded                     ,+++-- ** expanderGetLabel+    expanderGetLabel                        ,+++-- ** expanderGetLabelFill+    expanderGetLabelFill                    ,+++-- ** expanderGetLabelWidget+    expanderGetLabelWidget                  ,+++-- ** expanderGetResizeToplevel+    expanderGetResizeToplevel               ,+++-- ** expanderGetSpacing+    expanderGetSpacing                      ,+++-- ** expanderGetUseMarkup+    expanderGetUseMarkup                    ,+++-- ** expanderGetUseUnderline+    expanderGetUseUnderline                 ,+++-- ** expanderNew+    expanderNew                             ,+++-- ** expanderNewWithMnemonic+    expanderNewWithMnemonic                 ,+++-- ** expanderSetExpanded+    expanderSetExpanded                     ,+++-- ** expanderSetLabel+    expanderSetLabel                        ,+++-- ** expanderSetLabelFill+    expanderSetLabelFill                    ,+++-- ** expanderSetLabelWidget+    expanderSetLabelWidget                  ,+++-- ** expanderSetResizeToplevel+    expanderSetResizeToplevel               ,+++-- ** expanderSetSpacing+    expanderSetSpacing                      ,+++-- ** expanderSetUseMarkup+    expanderSetUseMarkup                    ,+++-- ** expanderSetUseUnderline+    expanderSetUseUnderline                 ,+++++ -- * Properties+-- ** Expanded+    ExpanderExpandedPropertyInfo            ,+    constructExpanderExpanded               ,+    getExpanderExpanded                     ,+    setExpanderExpanded                     ,+++-- ** Label+    ExpanderLabelPropertyInfo               ,+    constructExpanderLabel                  ,+    getExpanderLabel                        ,+    setExpanderLabel                        ,+++-- ** LabelFill+    ExpanderLabelFillPropertyInfo           ,+    constructExpanderLabelFill              ,+    getExpanderLabelFill                    ,+    setExpanderLabelFill                    ,+++-- ** LabelWidget+    ExpanderLabelWidgetPropertyInfo         ,+    constructExpanderLabelWidget            ,+    getExpanderLabelWidget                  ,+    setExpanderLabelWidget                  ,+++-- ** ResizeToplevel+    ExpanderResizeToplevelPropertyInfo      ,+    constructExpanderResizeToplevel         ,+    getExpanderResizeToplevel               ,+    setExpanderResizeToplevel               ,+++-- ** Spacing+    ExpanderSpacingPropertyInfo             ,+    constructExpanderSpacing                ,+    getExpanderSpacing                      ,+    setExpanderSpacing                      ,+++-- ** UseMarkup+    ExpanderUseMarkupPropertyInfo           ,+    constructExpanderUseMarkup              ,+    getExpanderUseMarkup                    ,+    setExpanderUseMarkup                    ,+++-- ** UseUnderline+    ExpanderUseUnderlinePropertyInfo        ,+    constructExpanderUseUnderline           ,+    getExpanderUseUnderline                 ,+    setExpanderUseUnderline                 ,+++++ -- * Signals+-- ** Activate+    ExpanderActivateCallback                ,+    ExpanderActivateCallbackC               ,+    ExpanderActivateSignalInfo              ,+    afterExpanderActivate                   ,+    expanderActivateCallbackWrapper         ,+    expanderActivateClosure                 ,+    mkExpanderActivateCallback              ,+    noExpanderActivateCallback              ,+    onExpanderActivate                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Expander = Expander (ForeignPtr Expander)+foreign import ccall "gtk_expander_get_type"+    c_gtk_expander_get_type :: IO GType++type instance ParentTypes Expander = ExpanderParentTypes+type ExpanderParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Expander where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_expander_get_type+    ++class GObject o => ExpanderK o+instance (GObject o, IsDescendantOf Expander o) => ExpanderK o++toExpander :: ExpanderK o => o -> IO Expander+toExpander = unsafeCastTo Expander++noExpander :: Maybe Expander+noExpander = Nothing++-- signal Expander::activate+type ExpanderActivateCallback =+    IO ()++noExpanderActivateCallback :: Maybe ExpanderActivateCallback+noExpanderActivateCallback = Nothing++type ExpanderActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkExpanderActivateCallback :: ExpanderActivateCallbackC -> IO (FunPtr ExpanderActivateCallbackC)++expanderActivateClosure :: ExpanderActivateCallback -> IO Closure+expanderActivateClosure cb = newCClosure =<< mkExpanderActivateCallback wrapped+    where wrapped = expanderActivateCallbackWrapper cb++expanderActivateCallbackWrapper ::+    ExpanderActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+expanderActivateCallbackWrapper _cb _ _ = do+    _cb ++onExpanderActivate :: (GObject a, MonadIO m) => a -> ExpanderActivateCallback -> m SignalHandlerId+onExpanderActivate obj cb = liftIO $ connectExpanderActivate obj cb SignalConnectBefore+afterExpanderActivate :: (GObject a, MonadIO m) => a -> ExpanderActivateCallback -> m SignalHandlerId+afterExpanderActivate obj cb = connectExpanderActivate obj cb SignalConnectAfter++connectExpanderActivate :: (GObject a, MonadIO m) =>+                           a -> ExpanderActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectExpanderActivate obj cb after = liftIO $ do+    cb' <- mkExpanderActivateCallback (expanderActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- VVV Prop "expanded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getExpanderExpanded :: (MonadIO m, ExpanderK o) => o -> m Bool+getExpanderExpanded obj = liftIO $ getObjectPropertyBool obj "expanded"++setExpanderExpanded :: (MonadIO m, ExpanderK o) => o -> Bool -> m ()+setExpanderExpanded obj val = liftIO $ setObjectPropertyBool obj "expanded" val++constructExpanderExpanded :: Bool -> IO ([Char], GValue)+constructExpanderExpanded val = constructObjectPropertyBool "expanded" val++data ExpanderExpandedPropertyInfo+instance AttrInfo ExpanderExpandedPropertyInfo where+    type AttrAllowedOps ExpanderExpandedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderExpandedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderExpandedPropertyInfo = ExpanderK+    type AttrGetType ExpanderExpandedPropertyInfo = Bool+    type AttrLabel ExpanderExpandedPropertyInfo = "Expander::expanded"+    attrGet _ = getExpanderExpanded+    attrSet _ = setExpanderExpanded+    attrConstruct _ = constructExpanderExpanded++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getExpanderLabel :: (MonadIO m, ExpanderK o) => o -> m T.Text+getExpanderLabel obj = liftIO $ getObjectPropertyString obj "label"++setExpanderLabel :: (MonadIO m, ExpanderK o) => o -> T.Text -> m ()+setExpanderLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructExpanderLabel :: T.Text -> IO ([Char], GValue)+constructExpanderLabel val = constructObjectPropertyString "label" val++data ExpanderLabelPropertyInfo+instance AttrInfo ExpanderLabelPropertyInfo where+    type AttrAllowedOps ExpanderLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ExpanderLabelPropertyInfo = ExpanderK+    type AttrGetType ExpanderLabelPropertyInfo = T.Text+    type AttrLabel ExpanderLabelPropertyInfo = "Expander::label"+    attrGet _ = getExpanderLabel+    attrSet _ = setExpanderLabel+    attrConstruct _ = constructExpanderLabel++-- VVV Prop "label-fill"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getExpanderLabelFill :: (MonadIO m, ExpanderK o) => o -> m Bool+getExpanderLabelFill obj = liftIO $ getObjectPropertyBool obj "label-fill"++setExpanderLabelFill :: (MonadIO m, ExpanderK o) => o -> Bool -> m ()+setExpanderLabelFill obj val = liftIO $ setObjectPropertyBool obj "label-fill" val++constructExpanderLabelFill :: Bool -> IO ([Char], GValue)+constructExpanderLabelFill val = constructObjectPropertyBool "label-fill" val++data ExpanderLabelFillPropertyInfo+instance AttrInfo ExpanderLabelFillPropertyInfo where+    type AttrAllowedOps ExpanderLabelFillPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderLabelFillPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderLabelFillPropertyInfo = ExpanderK+    type AttrGetType ExpanderLabelFillPropertyInfo = Bool+    type AttrLabel ExpanderLabelFillPropertyInfo = "Expander::label-fill"+    attrGet _ = getExpanderLabelFill+    attrSet _ = setExpanderLabelFill+    attrConstruct _ = constructExpanderLabelFill++-- VVV Prop "label-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getExpanderLabelWidget :: (MonadIO m, ExpanderK o) => o -> m Widget+getExpanderLabelWidget obj = liftIO $ getObjectPropertyObject obj "label-widget" Widget++setExpanderLabelWidget :: (MonadIO m, ExpanderK o, WidgetK a) => o -> a -> m ()+setExpanderLabelWidget obj val = liftIO $ setObjectPropertyObject obj "label-widget" val++constructExpanderLabelWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructExpanderLabelWidget val = constructObjectPropertyObject "label-widget" val++data ExpanderLabelWidgetPropertyInfo+instance AttrInfo ExpanderLabelWidgetPropertyInfo where+    type AttrAllowedOps ExpanderLabelWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderLabelWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint ExpanderLabelWidgetPropertyInfo = ExpanderK+    type AttrGetType ExpanderLabelWidgetPropertyInfo = Widget+    type AttrLabel ExpanderLabelWidgetPropertyInfo = "Expander::label-widget"+    attrGet _ = getExpanderLabelWidget+    attrSet _ = setExpanderLabelWidget+    attrConstruct _ = constructExpanderLabelWidget++-- VVV Prop "resize-toplevel"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getExpanderResizeToplevel :: (MonadIO m, ExpanderK o) => o -> m Bool+getExpanderResizeToplevel obj = liftIO $ getObjectPropertyBool obj "resize-toplevel"++setExpanderResizeToplevel :: (MonadIO m, ExpanderK o) => o -> Bool -> m ()+setExpanderResizeToplevel obj val = liftIO $ setObjectPropertyBool obj "resize-toplevel" val++constructExpanderResizeToplevel :: Bool -> IO ([Char], GValue)+constructExpanderResizeToplevel val = constructObjectPropertyBool "resize-toplevel" val++data ExpanderResizeToplevelPropertyInfo+instance AttrInfo ExpanderResizeToplevelPropertyInfo where+    type AttrAllowedOps ExpanderResizeToplevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderResizeToplevelPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderResizeToplevelPropertyInfo = ExpanderK+    type AttrGetType ExpanderResizeToplevelPropertyInfo = Bool+    type AttrLabel ExpanderResizeToplevelPropertyInfo = "Expander::resize-toplevel"+    attrGet _ = getExpanderResizeToplevel+    attrSet _ = setExpanderResizeToplevel+    attrConstruct _ = constructExpanderResizeToplevel++-- VVV Prop "spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getExpanderSpacing :: (MonadIO m, ExpanderK o) => o -> m Int32+getExpanderSpacing obj = liftIO $ getObjectPropertyCInt obj "spacing"++setExpanderSpacing :: (MonadIO m, ExpanderK o) => o -> Int32 -> m ()+setExpanderSpacing obj val = liftIO $ setObjectPropertyCInt obj "spacing" val++constructExpanderSpacing :: Int32 -> IO ([Char], GValue)+constructExpanderSpacing val = constructObjectPropertyCInt "spacing" val++data ExpanderSpacingPropertyInfo+instance AttrInfo ExpanderSpacingPropertyInfo where+    type AttrAllowedOps ExpanderSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ExpanderSpacingPropertyInfo = ExpanderK+    type AttrGetType ExpanderSpacingPropertyInfo = Int32+    type AttrLabel ExpanderSpacingPropertyInfo = "Expander::spacing"+    attrGet _ = getExpanderSpacing+    attrSet _ = setExpanderSpacing+    attrConstruct _ = constructExpanderSpacing++-- VVV Prop "use-markup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getExpanderUseMarkup :: (MonadIO m, ExpanderK o) => o -> m Bool+getExpanderUseMarkup obj = liftIO $ getObjectPropertyBool obj "use-markup"++setExpanderUseMarkup :: (MonadIO m, ExpanderK o) => o -> Bool -> m ()+setExpanderUseMarkup obj val = liftIO $ setObjectPropertyBool obj "use-markup" val++constructExpanderUseMarkup :: Bool -> IO ([Char], GValue)+constructExpanderUseMarkup val = constructObjectPropertyBool "use-markup" val++data ExpanderUseMarkupPropertyInfo+instance AttrInfo ExpanderUseMarkupPropertyInfo where+    type AttrAllowedOps ExpanderUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderUseMarkupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderUseMarkupPropertyInfo = ExpanderK+    type AttrGetType ExpanderUseMarkupPropertyInfo = Bool+    type AttrLabel ExpanderUseMarkupPropertyInfo = "Expander::use-markup"+    attrGet _ = getExpanderUseMarkup+    attrSet _ = setExpanderUseMarkup+    attrConstruct _ = constructExpanderUseMarkup++-- VVV Prop "use-underline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getExpanderUseUnderline :: (MonadIO m, ExpanderK o) => o -> m Bool+getExpanderUseUnderline obj = liftIO $ getObjectPropertyBool obj "use-underline"++setExpanderUseUnderline :: (MonadIO m, ExpanderK o) => o -> Bool -> m ()+setExpanderUseUnderline obj val = liftIO $ setObjectPropertyBool obj "use-underline" val++constructExpanderUseUnderline :: Bool -> IO ([Char], GValue)+constructExpanderUseUnderline val = constructObjectPropertyBool "use-underline" val++data ExpanderUseUnderlinePropertyInfo+instance AttrInfo ExpanderUseUnderlinePropertyInfo where+    type AttrAllowedOps ExpanderUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ExpanderUseUnderlinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ExpanderUseUnderlinePropertyInfo = ExpanderK+    type AttrGetType ExpanderUseUnderlinePropertyInfo = Bool+    type AttrLabel ExpanderUseUnderlinePropertyInfo = "Expander::use-underline"+    attrGet _ = getExpanderUseUnderline+    attrSet _ = setExpanderUseUnderline+    attrConstruct _ = constructExpanderUseUnderline++type instance AttributeList Expander = ExpanderAttributeList+type ExpanderAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("expanded", ExpanderExpandedPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ExpanderLabelPropertyInfo), '("label-fill", ExpanderLabelFillPropertyInfo), '("label-widget", ExpanderLabelWidgetPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("resize-toplevel", ExpanderResizeToplevelPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", ExpanderSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-markup", ExpanderUseMarkupPropertyInfo), '("use-underline", ExpanderUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data ExpanderActivateSignalInfo+instance SignalInfo ExpanderActivateSignalInfo where+    type HaskellCallbackType ExpanderActivateSignalInfo = ExpanderActivateCallback+    connectSignal _ = connectExpanderActivate++type instance SignalList Expander = ExpanderSignalList+type ExpanderSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ExpanderActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Expander::new+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Expander"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_new" gtk_expander_new :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Expander)+++expanderNew ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m Expander+expanderNew label = liftIO $ do+    label' <- textToCString label+    result <- gtk_expander_new label'+    checkUnexpectedReturnNULL "gtk_expander_new" result+    result' <- (newObject Expander) result+    freeMem label'+    return result'++-- method Expander::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", 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}]+-- returnType : TInterface "Gtk" "Expander"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_new_with_mnemonic" gtk_expander_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Expander)+++expanderNewWithMnemonic ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- label+    m Expander+expanderNewWithMnemonic label = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_expander_new_with_mnemonic maybeLabel+    checkUnexpectedReturnNULL "gtk_expander_new_with_mnemonic" result+    result' <- (newObject Expander) result+    freeMem maybeLabel+    return result'++-- method Expander::get_expanded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_expanded" gtk_expander_get_expanded :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CInt+++expanderGetExpanded ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Bool+expanderGetExpanded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_expanded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Expander::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_label" gtk_expander_get_label :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CString+++expanderGetLabel ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m T.Text+expanderGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_label _obj'+    checkUnexpectedReturnNULL "gtk_expander_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Expander::get_label_fill+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_label_fill" gtk_expander_get_label_fill :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CInt+++expanderGetLabelFill ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Bool+expanderGetLabelFill _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_label_fill _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Expander::get_label_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_label_widget" gtk_expander_get_label_widget :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO (Ptr Widget)+++expanderGetLabelWidget ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Widget+expanderGetLabelWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_label_widget _obj'+    checkUnexpectedReturnNULL "gtk_expander_get_label_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Expander::get_resize_toplevel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_resize_toplevel" gtk_expander_get_resize_toplevel :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CInt+++expanderGetResizeToplevel ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Bool+expanderGetResizeToplevel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_resize_toplevel _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Expander::get_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_spacing" gtk_expander_get_spacing :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO Int32+++expanderGetSpacing ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Int32+expanderGetSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_spacing _obj'+    touchManagedPtr _obj+    return result++-- method Expander::get_use_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_use_markup" gtk_expander_get_use_markup :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CInt+++expanderGetUseMarkup ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Bool+expanderGetUseMarkup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_use_markup _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Expander::get_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_get_use_underline" gtk_expander_get_use_underline :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    IO CInt+++expanderGetUseUnderline ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    m Bool+expanderGetUseUnderline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_expander_get_use_underline _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Expander::set_expanded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expanded", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "expanded", 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 "gtk_expander_set_expanded" gtk_expander_set_expanded :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CInt ->                                 -- expanded : TBasicType TBoolean+    IO ()+++expanderSetExpanded ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- expanded+    m ()+expanderSetExpanded _obj expanded = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let expanded' = (fromIntegral . fromEnum) expanded+    gtk_expander_set_expanded _obj' expanded'+    touchManagedPtr _obj+    return ()++-- method Expander::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", 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 "Gtk" "Expander", 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 "gtk_expander_set_label" gtk_expander_set_label :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++expanderSetLabel ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+expanderSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    gtk_expander_set_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method Expander::set_label_fill+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_fill", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_fill", 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 "gtk_expander_set_label_fill" gtk_expander_set_label_fill :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CInt ->                                 -- label_fill : TBasicType TBoolean+    IO ()+++expanderSetLabelFill ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- label_fill+    m ()+expanderSetLabelFill _obj label_fill = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let label_fill' = (fromIntegral . fromEnum) label_fill+    gtk_expander_set_label_fill _obj' label_fill'+    touchManagedPtr _obj+    return ()++-- method Expander::set_label_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_expander_set_label_widget" gtk_expander_set_label_widget :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    Ptr Widget ->                           -- label_widget : TInterface "Gtk" "Widget"+    IO ()+++expanderSetLabelWidget ::+    (MonadIO m, ExpanderK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- label_widget+    m ()+expanderSetLabelWidget _obj label_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel_widget <- case label_widget of+        Nothing -> return nullPtr+        Just jLabel_widget -> do+            let jLabel_widget' = unsafeManagedPtrCastPtr jLabel_widget+            return jLabel_widget'+    gtk_expander_set_label_widget _obj' maybeLabel_widget+    touchManagedPtr _obj+    whenJust label_widget touchManagedPtr+    return ()++-- method Expander::set_resize_toplevel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize_toplevel", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize_toplevel", 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 "gtk_expander_set_resize_toplevel" gtk_expander_set_resize_toplevel :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CInt ->                                 -- resize_toplevel : TBasicType TBoolean+    IO ()+++expanderSetResizeToplevel ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- resize_toplevel+    m ()+expanderSetResizeToplevel _obj resize_toplevel = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let resize_toplevel' = (fromIntegral . fromEnum) resize_toplevel+    gtk_expander_set_resize_toplevel _obj' resize_toplevel'+    touchManagedPtr _obj+    return ()++-- method Expander::set_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_expander_set_spacing" gtk_expander_set_spacing :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    Int32 ->                                -- spacing : TBasicType TInt32+    IO ()+++expanderSetSpacing ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- spacing+    m ()+expanderSetSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_expander_set_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++-- method Expander::set_use_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_markup", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_markup", 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 "gtk_expander_set_use_markup" gtk_expander_set_use_markup :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CInt ->                                 -- use_markup : TBasicType TBoolean+    IO ()+++expanderSetUseMarkup ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_markup+    m ()+expanderSetUseMarkup _obj use_markup = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_markup' = (fromIntegral . fromEnum) use_markup+    gtk_expander_set_use_markup _obj' use_markup'+    touchManagedPtr _obj+    return ()++-- method Expander::set_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_underline", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Expander", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_underline", 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 "gtk_expander_set_use_underline" gtk_expander_set_use_underline :: +    Ptr Expander ->                         -- _obj : TInterface "Gtk" "Expander"+    CInt ->                                 -- use_underline : TBasicType TBoolean+    IO ()+++expanderSetUseUnderline ::+    (MonadIO m, ExpanderK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_underline+    m ()+expanderSetUseUnderline _obj use_underline = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_underline' = (fromIntegral . fromEnum) use_underline+    gtk_expander_set_use_underline _obj' use_underline'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Expander.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gtk.Objects.Expander where++import Prelude ()+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 Expander = Expander (ForeignPtr Expander)+instance GObject Expander where+class GObject o => ExpanderK o+instance (GObject o, IsDescendantOf Expander o) => ExpanderK o+data ExpanderExpandedPropertyInfo+data ExpanderLabelPropertyInfo+data ExpanderLabelFillPropertyInfo+data ExpanderLabelWidgetPropertyInfo+data ExpanderResizeToplevelPropertyInfo+data ExpanderSpacingPropertyInfo+data ExpanderUseMarkupPropertyInfo+data ExpanderUseUnderlinePropertyInfo+data ExpanderActivateSignalInfo
+ GI/Gtk/Objects/ExpanderAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ExpanderAccessible+    ( ++-- * Exported types+    ExpanderAccessible(..)                  ,+    ExpanderAccessibleK                     ,+    toExpanderAccessible                    ,+    noExpanderAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ExpanderAccessible = ExpanderAccessible (ForeignPtr ExpanderAccessible)+foreign import ccall "gtk_expander_accessible_get_type"+    c_gtk_expander_accessible_get_type :: IO GType++type instance ParentTypes ExpanderAccessible = ExpanderAccessibleParentTypes+type ExpanderAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component]++instance GObject ExpanderAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_expander_accessible_get_type+    ++class GObject o => ExpanderAccessibleK o+instance (GObject o, IsDescendantOf ExpanderAccessible o) => ExpanderAccessibleK o++toExpanderAccessible :: ExpanderAccessibleK o => o -> IO ExpanderAccessible+toExpanderAccessible = unsafeCastTo ExpanderAccessible++noExpanderAccessible :: Maybe ExpanderAccessible+noExpanderAccessible = Nothing++type instance AttributeList ExpanderAccessible = ExpanderAccessibleAttributeList+type ExpanderAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ExpanderAccessible = ExpanderAccessibleSignalList+type ExpanderAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ExpanderAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ExpanderAccessible where++import Prelude ()+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 ExpanderAccessible = ExpanderAccessible (ForeignPtr ExpanderAccessible)+instance GObject ExpanderAccessible where+class GObject o => ExpanderAccessibleK o+instance (GObject o, IsDescendantOf ExpanderAccessible o) => ExpanderAccessibleK o
+ GI/Gtk/Objects/FileChooserButton.hs view
@@ -0,0 +1,482 @@++{- |+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.Gtk.Objects.FileChooserButton+    ( ++-- * Exported types+    FileChooserButton(..)                   ,+    FileChooserButtonK                      ,+    toFileChooserButton                     ,+    noFileChooserButton                     ,+++ -- * Methods+-- ** fileChooserButtonGetFocusOnClick+    fileChooserButtonGetFocusOnClick        ,+++-- ** fileChooserButtonGetTitle+    fileChooserButtonGetTitle               ,+++-- ** fileChooserButtonGetWidthChars+    fileChooserButtonGetWidthChars          ,+++-- ** fileChooserButtonNew+    fileChooserButtonNew                    ,+++-- ** fileChooserButtonNewWithDialog+    fileChooserButtonNewWithDialog          ,+++-- ** fileChooserButtonSetFocusOnClick+    fileChooserButtonSetFocusOnClick        ,+++-- ** fileChooserButtonSetTitle+    fileChooserButtonSetTitle               ,+++-- ** fileChooserButtonSetWidthChars+    fileChooserButtonSetWidthChars          ,+++++ -- * Properties+-- ** Dialog+    FileChooserButtonDialogPropertyInfo     ,+    constructFileChooserButtonDialog        ,+++-- ** FocusOnClick+    FileChooserButtonFocusOnClickPropertyInfo,+    constructFileChooserButtonFocusOnClick  ,+    getFileChooserButtonFocusOnClick        ,+    setFileChooserButtonFocusOnClick        ,+++-- ** Title+    FileChooserButtonTitlePropertyInfo      ,+    constructFileChooserButtonTitle         ,+    getFileChooserButtonTitle               ,+    setFileChooserButtonTitle               ,+++-- ** WidthChars+    FileChooserButtonWidthCharsPropertyInfo ,+    constructFileChooserButtonWidthChars    ,+    getFileChooserButtonWidthChars          ,+    setFileChooserButtonWidthChars          ,+++++ -- * Signals+-- ** FileSet+    FileChooserButtonFileSetCallback        ,+    FileChooserButtonFileSetCallbackC       ,+    FileChooserButtonFileSetSignalInfo      ,+    afterFileChooserButtonFileSet           ,+    fileChooserButtonFileSetCallbackWrapper ,+    fileChooserButtonFileSetClosure         ,+    mkFileChooserButtonFileSetCallback      ,+    noFileChooserButtonFileSetCallback      ,+    onFileChooserButtonFileSet              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FileChooserButton = FileChooserButton (ForeignPtr FileChooserButton)+foreign import ccall "gtk_file_chooser_button_get_type"+    c_gtk_file_chooser_button_get_type :: IO GType++type instance ParentTypes FileChooserButton = FileChooserButtonParentTypes+type FileChooserButtonParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, FileChooser, Orientable]++instance GObject FileChooserButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_file_chooser_button_get_type+    ++class GObject o => FileChooserButtonK o+instance (GObject o, IsDescendantOf FileChooserButton o) => FileChooserButtonK o++toFileChooserButton :: FileChooserButtonK o => o -> IO FileChooserButton+toFileChooserButton = unsafeCastTo FileChooserButton++noFileChooserButton :: Maybe FileChooserButton+noFileChooserButton = Nothing++-- signal FileChooserButton::file-set+type FileChooserButtonFileSetCallback =+    IO ()++noFileChooserButtonFileSetCallback :: Maybe FileChooserButtonFileSetCallback+noFileChooserButtonFileSetCallback = Nothing++type FileChooserButtonFileSetCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserButtonFileSetCallback :: FileChooserButtonFileSetCallbackC -> IO (FunPtr FileChooserButtonFileSetCallbackC)++fileChooserButtonFileSetClosure :: FileChooserButtonFileSetCallback -> IO Closure+fileChooserButtonFileSetClosure cb = newCClosure =<< mkFileChooserButtonFileSetCallback wrapped+    where wrapped = fileChooserButtonFileSetCallbackWrapper cb++fileChooserButtonFileSetCallbackWrapper ::+    FileChooserButtonFileSetCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserButtonFileSetCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserButtonFileSet :: (GObject a, MonadIO m) => a -> FileChooserButtonFileSetCallback -> m SignalHandlerId+onFileChooserButtonFileSet obj cb = liftIO $ connectFileChooserButtonFileSet obj cb SignalConnectBefore+afterFileChooserButtonFileSet :: (GObject a, MonadIO m) => a -> FileChooserButtonFileSetCallback -> m SignalHandlerId+afterFileChooserButtonFileSet obj cb = connectFileChooserButtonFileSet obj cb SignalConnectAfter++connectFileChooserButtonFileSet :: (GObject a, MonadIO m) =>+                                   a -> FileChooserButtonFileSetCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserButtonFileSet obj cb after = liftIO $ do+    cb' <- mkFileChooserButtonFileSetCallback (fileChooserButtonFileSetCallbackWrapper cb)+    connectSignalFunPtr obj "file-set" cb' after++-- VVV Prop "dialog"+   -- Type: TInterface "Gtk" "FileChooser"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructFileChooserButtonDialog :: (FileChooserK a) => a -> IO ([Char], GValue)+constructFileChooserButtonDialog val = constructObjectPropertyObject "dialog" val++data FileChooserButtonDialogPropertyInfo+instance AttrInfo FileChooserButtonDialogPropertyInfo where+    type AttrAllowedOps FileChooserButtonDialogPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint FileChooserButtonDialogPropertyInfo = FileChooserK+    type AttrBaseTypeConstraint FileChooserButtonDialogPropertyInfo = FileChooserButtonK+    type AttrGetType FileChooserButtonDialogPropertyInfo = ()+    type AttrLabel FileChooserButtonDialogPropertyInfo = "FileChooserButton::dialog"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructFileChooserButtonDialog++-- VVV Prop "focus-on-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserButtonFocusOnClick :: (MonadIO m, FileChooserButtonK o) => o -> m Bool+getFileChooserButtonFocusOnClick obj = liftIO $ getObjectPropertyBool obj "focus-on-click"++setFileChooserButtonFocusOnClick :: (MonadIO m, FileChooserButtonK o) => o -> Bool -> m ()+setFileChooserButtonFocusOnClick obj val = liftIO $ setObjectPropertyBool obj "focus-on-click" val++constructFileChooserButtonFocusOnClick :: Bool -> IO ([Char], GValue)+constructFileChooserButtonFocusOnClick val = constructObjectPropertyBool "focus-on-click" val++data FileChooserButtonFocusOnClickPropertyInfo+instance AttrInfo FileChooserButtonFocusOnClickPropertyInfo where+    type AttrAllowedOps FileChooserButtonFocusOnClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserButtonFocusOnClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserButtonFocusOnClickPropertyInfo = FileChooserButtonK+    type AttrGetType FileChooserButtonFocusOnClickPropertyInfo = Bool+    type AttrLabel FileChooserButtonFocusOnClickPropertyInfo = "FileChooserButton::focus-on-click"+    attrGet _ = getFileChooserButtonFocusOnClick+    attrSet _ = setFileChooserButtonFocusOnClick+    attrConstruct _ = constructFileChooserButtonFocusOnClick++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserButtonTitle :: (MonadIO m, FileChooserButtonK o) => o -> m T.Text+getFileChooserButtonTitle obj = liftIO $ getObjectPropertyString obj "title"++setFileChooserButtonTitle :: (MonadIO m, FileChooserButtonK o) => o -> T.Text -> m ()+setFileChooserButtonTitle obj val = liftIO $ setObjectPropertyString obj "title" val++constructFileChooserButtonTitle :: T.Text -> IO ([Char], GValue)+constructFileChooserButtonTitle val = constructObjectPropertyString "title" val++data FileChooserButtonTitlePropertyInfo+instance AttrInfo FileChooserButtonTitlePropertyInfo where+    type AttrAllowedOps FileChooserButtonTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserButtonTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FileChooserButtonTitlePropertyInfo = FileChooserButtonK+    type AttrGetType FileChooserButtonTitlePropertyInfo = T.Text+    type AttrLabel FileChooserButtonTitlePropertyInfo = "FileChooserButton::title"+    attrGet _ = getFileChooserButtonTitle+    attrSet _ = setFileChooserButtonTitle+    attrConstruct _ = constructFileChooserButtonTitle++-- VVV Prop "width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserButtonWidthChars :: (MonadIO m, FileChooserButtonK o) => o -> m Int32+getFileChooserButtonWidthChars obj = liftIO $ getObjectPropertyCInt obj "width-chars"++setFileChooserButtonWidthChars :: (MonadIO m, FileChooserButtonK o) => o -> Int32 -> m ()+setFileChooserButtonWidthChars obj val = liftIO $ setObjectPropertyCInt obj "width-chars" val++constructFileChooserButtonWidthChars :: Int32 -> IO ([Char], GValue)+constructFileChooserButtonWidthChars val = constructObjectPropertyCInt "width-chars" val++data FileChooserButtonWidthCharsPropertyInfo+instance AttrInfo FileChooserButtonWidthCharsPropertyInfo where+    type AttrAllowedOps FileChooserButtonWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserButtonWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint FileChooserButtonWidthCharsPropertyInfo = FileChooserButtonK+    type AttrGetType FileChooserButtonWidthCharsPropertyInfo = Int32+    type AttrLabel FileChooserButtonWidthCharsPropertyInfo = "FileChooserButton::width-chars"+    attrGet _ = getFileChooserButtonWidthChars+    attrSet _ = setFileChooserButtonWidthChars+    attrConstruct _ = constructFileChooserButtonWidthChars++type instance AttributeList FileChooserButton = FileChooserButtonAttributeList+type FileChooserButtonAttributeList = ('[ '("action", FileChooserActionPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("create-folders", FileChooserCreateFoldersPropertyInfo), '("dialog", FileChooserButtonDialogPropertyInfo), '("do-overwrite-confirmation", FileChooserDoOverwriteConfirmationPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("extra-widget", FileChooserExtraWidgetPropertyInfo), '("filter", FileChooserFilterPropertyInfo), '("focus-on-click", FileChooserButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("local-only", FileChooserLocalOnlyPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-widget", FileChooserPreviewWidgetPropertyInfo), '("preview-widget-active", FileChooserPreviewWidgetActivePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("select-multiple", FileChooserSelectMultiplePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-hidden", FileChooserShowHiddenPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", FileChooserButtonTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-preview-label", FileChooserUsePreviewLabelPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-chars", FileChooserButtonWidthCharsPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data FileChooserButtonFileSetSignalInfo+instance SignalInfo FileChooserButtonFileSetSignalInfo where+    type HaskellCallbackType FileChooserButtonFileSetSignalInfo = FileChooserButtonFileSetCallback+    connectSignal _ = connectFileChooserButtonFileSet++type instance SignalList FileChooserButton = FileChooserButtonSignalList+type FileChooserButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("confirm-overwrite", FileChooserConfirmOverwriteSignalInfo), '("current-folder-changed", FileChooserCurrentFolderChangedSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("file-activated", FileChooserFileActivatedSignalInfo), '("file-set", FileChooserButtonFileSetSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-changed", FileChooserSelectionChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("update-preview", FileChooserUpdatePreviewSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileChooserButton::new+-- method type : Constructor+-- Args : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", 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},Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileChooserButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_button_new" gtk_file_chooser_button_new :: +    CString ->                              -- title : TBasicType TUTF8+    CUInt ->                                -- action : TInterface "Gtk" "FileChooserAction"+    IO (Ptr FileChooserButton)+++fileChooserButtonNew ::+    (MonadIO m) =>+    T.Text ->                               -- title+    FileChooserAction ->                    -- action+    m FileChooserButton+fileChooserButtonNew title action = liftIO $ do+    title' <- textToCString title+    let action' = (fromIntegral . fromEnum) action+    result <- gtk_file_chooser_button_new title' action'+    checkUnexpectedReturnNULL "gtk_file_chooser_button_new" result+    result' <- (newObject FileChooserButton) result+    freeMem title'+    return result'++-- method FileChooserButton::new_with_dialog+-- method type : Constructor+-- Args : [Arg {argName = "dialog", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "dialog", argType = TInterface "Gtk" "Dialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileChooserButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_button_new_with_dialog" gtk_file_chooser_button_new_with_dialog :: +    Ptr Dialog ->                           -- dialog : TInterface "Gtk" "Dialog"+    IO (Ptr FileChooserButton)+++fileChooserButtonNewWithDialog ::+    (MonadIO m, DialogK a) =>+    a ->                                    -- dialog+    m FileChooserButton+fileChooserButtonNewWithDialog dialog = liftIO $ do+    let dialog' = unsafeManagedPtrCastPtr dialog+    result <- gtk_file_chooser_button_new_with_dialog dialog'+    checkUnexpectedReturnNULL "gtk_file_chooser_button_new_with_dialog" result+    result' <- (newObject FileChooserButton) result+    touchManagedPtr dialog+    return result'++-- method FileChooserButton::get_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_button_get_focus_on_click" gtk_file_chooser_button_get_focus_on_click :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    IO CInt+++fileChooserButtonGetFocusOnClick ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    m Bool+fileChooserButtonGetFocusOnClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_button_get_focus_on_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FileChooserButton::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_button_get_title" gtk_file_chooser_button_get_title :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    IO CString+++fileChooserButtonGetTitle ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    m T.Text+fileChooserButtonGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_button_get_title _obj'+    checkUnexpectedReturnNULL "gtk_file_chooser_button_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileChooserButton::get_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_button_get_width_chars" gtk_file_chooser_button_get_width_chars :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    IO Int32+++fileChooserButtonGetWidthChars ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    m Int32+fileChooserButtonGetWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_chooser_button_get_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method FileChooserButton::set_focus_on_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "focus_on_click", 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 "gtk_file_chooser_button_set_focus_on_click" gtk_file_chooser_button_set_focus_on_click :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    CInt ->                                 -- focus_on_click : TBasicType TBoolean+    IO ()+++fileChooserButtonSetFocusOnClick ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- focus_on_click+    m ()+fileChooserButtonSetFocusOnClick _obj focus_on_click = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let focus_on_click' = (fromIntegral . fromEnum) focus_on_click+    gtk_file_chooser_button_set_focus_on_click _obj' focus_on_click'+    touchManagedPtr _obj+    return ()++-- method FileChooserButton::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", 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 "Gtk" "FileChooserButton", 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 "gtk_file_chooser_button_set_title" gtk_file_chooser_button_set_title :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++fileChooserButtonSetTitle ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+fileChooserButtonSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    gtk_file_chooser_button_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method FileChooserButton::set_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileChooserButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_file_chooser_button_set_width_chars" gtk_file_chooser_button_set_width_chars :: +    Ptr FileChooserButton ->                -- _obj : TInterface "Gtk" "FileChooserButton"+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++fileChooserButtonSetWidthChars ::+    (MonadIO m, FileChooserButtonK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_chars+    m ()+fileChooserButtonSetWidthChars _obj n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_file_chooser_button_set_width_chars _obj' n_chars+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/FileChooserButton.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.FileChooserButton where++import Prelude ()+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 FileChooserButton = FileChooserButton (ForeignPtr FileChooserButton)+instance GObject FileChooserButton where+class GObject o => FileChooserButtonK o+instance (GObject o, IsDescendantOf FileChooserButton o) => FileChooserButtonK o+data FileChooserButtonDialogPropertyInfo+data FileChooserButtonFocusOnClickPropertyInfo+data FileChooserButtonTitlePropertyInfo+data FileChooserButtonWidthCharsPropertyInfo+data FileChooserButtonFileSetSignalInfo
+ GI/Gtk/Objects/FileChooserDialog.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.FileChooserDialog+    ( ++-- * Exported types+    FileChooserDialog(..)                   ,+    FileChooserDialogK                      ,+    toFileChooserDialog                     ,+    noFileChooserDialog                     ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FileChooserDialog = FileChooserDialog (ForeignPtr FileChooserDialog)+foreign import ccall "gtk_file_chooser_dialog_get_type"+    c_gtk_file_chooser_dialog_get_type :: IO GType++type instance ParentTypes FileChooserDialog = FileChooserDialogParentTypes+type FileChooserDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, FileChooser]++instance GObject FileChooserDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_file_chooser_dialog_get_type+    ++class GObject o => FileChooserDialogK o+instance (GObject o, IsDescendantOf FileChooserDialog o) => FileChooserDialogK o++toFileChooserDialog :: FileChooserDialogK o => o -> IO FileChooserDialog+toFileChooserDialog = unsafeCastTo FileChooserDialog++noFileChooserDialog :: Maybe FileChooserDialog+noFileChooserDialog = Nothing++type instance AttributeList FileChooserDialog = FileChooserDialogAttributeList+type FileChooserDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("action", FileChooserActionPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("create-folders", FileChooserCreateFoldersPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("do-overwrite-confirmation", FileChooserDoOverwriteConfirmationPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("extra-widget", FileChooserExtraWidgetPropertyInfo), '("filter", FileChooserFilterPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("local-only", FileChooserLocalOnlyPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-widget", FileChooserPreviewWidgetPropertyInfo), '("preview-widget-active", FileChooserPreviewWidgetActivePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("select-multiple", FileChooserSelectMultiplePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-hidden", FileChooserShowHiddenPropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("use-preview-label", FileChooserUsePreviewLabelPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FileChooserDialog = FileChooserDialogSignalList+type FileChooserDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("confirm-overwrite", FileChooserConfirmOverwriteSignalInfo), '("current-folder-changed", FileChooserCurrentFolderChangedSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("file-activated", FileChooserFileActivatedSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-changed", FileChooserSelectionChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("update-preview", FileChooserUpdatePreviewSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/FileChooserDialog.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FileChooserDialog where++import Prelude ()+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 FileChooserDialog = FileChooserDialog (ForeignPtr FileChooserDialog)+instance GObject FileChooserDialog where+class GObject o => FileChooserDialogK o+instance (GObject o, IsDescendantOf FileChooserDialog o) => FileChooserDialogK o
+ GI/Gtk/Objects/FileChooserWidget.hs view
@@ -0,0 +1,818 @@++{- |+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.Gtk.Objects.FileChooserWidget+    ( ++-- * Exported types+    FileChooserWidget(..)                   ,+    FileChooserWidgetK                      ,+    toFileChooserWidget                     ,+    noFileChooserWidget                     ,+++ -- * Methods+-- ** fileChooserWidgetNew+    fileChooserWidgetNew                    ,+++++ -- * Properties+-- ** SearchMode+    FileChooserWidgetSearchModePropertyInfo ,+    constructFileChooserWidgetSearchMode    ,+    getFileChooserWidgetSearchMode          ,+    setFileChooserWidgetSearchMode          ,+++-- ** Subtitle+    FileChooserWidgetSubtitlePropertyInfo   ,+    getFileChooserWidgetSubtitle            ,+++++ -- * Signals+-- ** DesktopFolder+    FileChooserWidgetDesktopFolderCallback  ,+    FileChooserWidgetDesktopFolderCallbackC ,+    FileChooserWidgetDesktopFolderSignalInfo,+    afterFileChooserWidgetDesktopFolder     ,+    fileChooserWidgetDesktopFolderCallbackWrapper,+    fileChooserWidgetDesktopFolderClosure   ,+    mkFileChooserWidgetDesktopFolderCallback,+    noFileChooserWidgetDesktopFolderCallback,+    onFileChooserWidgetDesktopFolder        ,+++-- ** DownFolder+    FileChooserWidgetDownFolderCallback     ,+    FileChooserWidgetDownFolderCallbackC    ,+    FileChooserWidgetDownFolderSignalInfo   ,+    afterFileChooserWidgetDownFolder        ,+    fileChooserWidgetDownFolderCallbackWrapper,+    fileChooserWidgetDownFolderClosure      ,+    mkFileChooserWidgetDownFolderCallback   ,+    noFileChooserWidgetDownFolderCallback   ,+    onFileChooserWidgetDownFolder           ,+++-- ** HomeFolder+    FileChooserWidgetHomeFolderCallback     ,+    FileChooserWidgetHomeFolderCallbackC    ,+    FileChooserWidgetHomeFolderSignalInfo   ,+    afterFileChooserWidgetHomeFolder        ,+    fileChooserWidgetHomeFolderCallbackWrapper,+    fileChooserWidgetHomeFolderClosure      ,+    mkFileChooserWidgetHomeFolderCallback   ,+    noFileChooserWidgetHomeFolderCallback   ,+    onFileChooserWidgetHomeFolder           ,+++-- ** LocationPopup+    FileChooserWidgetLocationPopupCallback  ,+    FileChooserWidgetLocationPopupCallbackC ,+    FileChooserWidgetLocationPopupSignalInfo,+    afterFileChooserWidgetLocationPopup     ,+    fileChooserWidgetLocationPopupCallbackWrapper,+    fileChooserWidgetLocationPopupClosure   ,+    mkFileChooserWidgetLocationPopupCallback,+    noFileChooserWidgetLocationPopupCallback,+    onFileChooserWidgetLocationPopup        ,+++-- ** LocationPopupOnPaste+    FileChooserWidgetLocationPopupOnPasteCallback,+    FileChooserWidgetLocationPopupOnPasteCallbackC,+    FileChooserWidgetLocationPopupOnPasteSignalInfo,+    afterFileChooserWidgetLocationPopupOnPaste,+    fileChooserWidgetLocationPopupOnPasteCallbackWrapper,+    fileChooserWidgetLocationPopupOnPasteClosure,+    mkFileChooserWidgetLocationPopupOnPasteCallback,+    noFileChooserWidgetLocationPopupOnPasteCallback,+    onFileChooserWidgetLocationPopupOnPaste ,+++-- ** LocationTogglePopup+    FileChooserWidgetLocationTogglePopupCallback,+    FileChooserWidgetLocationTogglePopupCallbackC,+    FileChooserWidgetLocationTogglePopupSignalInfo,+    afterFileChooserWidgetLocationTogglePopup,+    fileChooserWidgetLocationTogglePopupCallbackWrapper,+    fileChooserWidgetLocationTogglePopupClosure,+    mkFileChooserWidgetLocationTogglePopupCallback,+    noFileChooserWidgetLocationTogglePopupCallback,+    onFileChooserWidgetLocationTogglePopup  ,+++-- ** PlacesShortcut+    FileChooserWidgetPlacesShortcutCallback ,+    FileChooserWidgetPlacesShortcutCallbackC,+    FileChooserWidgetPlacesShortcutSignalInfo,+    afterFileChooserWidgetPlacesShortcut    ,+    fileChooserWidgetPlacesShortcutCallbackWrapper,+    fileChooserWidgetPlacesShortcutClosure  ,+    mkFileChooserWidgetPlacesShortcutCallback,+    noFileChooserWidgetPlacesShortcutCallback,+    onFileChooserWidgetPlacesShortcut       ,+++-- ** QuickBookmark+    FileChooserWidgetQuickBookmarkCallback  ,+    FileChooserWidgetQuickBookmarkCallbackC ,+    FileChooserWidgetQuickBookmarkSignalInfo,+    afterFileChooserWidgetQuickBookmark     ,+    fileChooserWidgetQuickBookmarkCallbackWrapper,+    fileChooserWidgetQuickBookmarkClosure   ,+    mkFileChooserWidgetQuickBookmarkCallback,+    noFileChooserWidgetQuickBookmarkCallback,+    onFileChooserWidgetQuickBookmark        ,+++-- ** RecentShortcut+    FileChooserWidgetRecentShortcutCallback ,+    FileChooserWidgetRecentShortcutCallbackC,+    FileChooserWidgetRecentShortcutSignalInfo,+    afterFileChooserWidgetRecentShortcut    ,+    fileChooserWidgetRecentShortcutCallbackWrapper,+    fileChooserWidgetRecentShortcutClosure  ,+    mkFileChooserWidgetRecentShortcutCallback,+    noFileChooserWidgetRecentShortcutCallback,+    onFileChooserWidgetRecentShortcut       ,+++-- ** SearchShortcut+    FileChooserWidgetSearchShortcutCallback ,+    FileChooserWidgetSearchShortcutCallbackC,+    FileChooserWidgetSearchShortcutSignalInfo,+    afterFileChooserWidgetSearchShortcut    ,+    fileChooserWidgetSearchShortcutCallbackWrapper,+    fileChooserWidgetSearchShortcutClosure  ,+    mkFileChooserWidgetSearchShortcutCallback,+    noFileChooserWidgetSearchShortcutCallback,+    onFileChooserWidgetSearchShortcut       ,+++-- ** ShowHidden+    FileChooserWidgetShowHiddenCallback     ,+    FileChooserWidgetShowHiddenCallbackC    ,+    FileChooserWidgetShowHiddenSignalInfo   ,+    afterFileChooserWidgetShowHidden        ,+    fileChooserWidgetShowHiddenCallbackWrapper,+    fileChooserWidgetShowHiddenClosure      ,+    mkFileChooserWidgetShowHiddenCallback   ,+    noFileChooserWidgetShowHiddenCallback   ,+    onFileChooserWidgetShowHidden           ,+++-- ** UpFolder+    FileChooserWidgetUpFolderCallback       ,+    FileChooserWidgetUpFolderCallbackC      ,+    FileChooserWidgetUpFolderSignalInfo     ,+    afterFileChooserWidgetUpFolder          ,+    fileChooserWidgetUpFolderCallbackWrapper,+    fileChooserWidgetUpFolderClosure        ,+    mkFileChooserWidgetUpFolderCallback     ,+    noFileChooserWidgetUpFolderCallback     ,+    onFileChooserWidgetUpFolder             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FileChooserWidget = FileChooserWidget (ForeignPtr FileChooserWidget)+foreign import ccall "gtk_file_chooser_widget_get_type"+    c_gtk_file_chooser_widget_get_type :: IO GType++type instance ParentTypes FileChooserWidget = FileChooserWidgetParentTypes+type FileChooserWidgetParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, FileChooser, Orientable]++instance GObject FileChooserWidget where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_file_chooser_widget_get_type+    ++class GObject o => FileChooserWidgetK o+instance (GObject o, IsDescendantOf FileChooserWidget o) => FileChooserWidgetK o++toFileChooserWidget :: FileChooserWidgetK o => o -> IO FileChooserWidget+toFileChooserWidget = unsafeCastTo FileChooserWidget++noFileChooserWidget :: Maybe FileChooserWidget+noFileChooserWidget = Nothing++-- signal FileChooserWidget::desktop-folder+type FileChooserWidgetDesktopFolderCallback =+    IO ()++noFileChooserWidgetDesktopFolderCallback :: Maybe FileChooserWidgetDesktopFolderCallback+noFileChooserWidgetDesktopFolderCallback = Nothing++type FileChooserWidgetDesktopFolderCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetDesktopFolderCallback :: FileChooserWidgetDesktopFolderCallbackC -> IO (FunPtr FileChooserWidgetDesktopFolderCallbackC)++fileChooserWidgetDesktopFolderClosure :: FileChooserWidgetDesktopFolderCallback -> IO Closure+fileChooserWidgetDesktopFolderClosure cb = newCClosure =<< mkFileChooserWidgetDesktopFolderCallback wrapped+    where wrapped = fileChooserWidgetDesktopFolderCallbackWrapper cb++fileChooserWidgetDesktopFolderCallbackWrapper ::+    FileChooserWidgetDesktopFolderCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetDesktopFolderCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetDesktopFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetDesktopFolderCallback -> m SignalHandlerId+onFileChooserWidgetDesktopFolder obj cb = liftIO $ connectFileChooserWidgetDesktopFolder obj cb SignalConnectBefore+afterFileChooserWidgetDesktopFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetDesktopFolderCallback -> m SignalHandlerId+afterFileChooserWidgetDesktopFolder obj cb = connectFileChooserWidgetDesktopFolder obj cb SignalConnectAfter++connectFileChooserWidgetDesktopFolder :: (GObject a, MonadIO m) =>+                                         a -> FileChooserWidgetDesktopFolderCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetDesktopFolder obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetDesktopFolderCallback (fileChooserWidgetDesktopFolderCallbackWrapper cb)+    connectSignalFunPtr obj "desktop-folder" cb' after++-- signal FileChooserWidget::down-folder+type FileChooserWidgetDownFolderCallback =+    IO ()++noFileChooserWidgetDownFolderCallback :: Maybe FileChooserWidgetDownFolderCallback+noFileChooserWidgetDownFolderCallback = Nothing++type FileChooserWidgetDownFolderCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetDownFolderCallback :: FileChooserWidgetDownFolderCallbackC -> IO (FunPtr FileChooserWidgetDownFolderCallbackC)++fileChooserWidgetDownFolderClosure :: FileChooserWidgetDownFolderCallback -> IO Closure+fileChooserWidgetDownFolderClosure cb = newCClosure =<< mkFileChooserWidgetDownFolderCallback wrapped+    where wrapped = fileChooserWidgetDownFolderCallbackWrapper cb++fileChooserWidgetDownFolderCallbackWrapper ::+    FileChooserWidgetDownFolderCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetDownFolderCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetDownFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetDownFolderCallback -> m SignalHandlerId+onFileChooserWidgetDownFolder obj cb = liftIO $ connectFileChooserWidgetDownFolder obj cb SignalConnectBefore+afterFileChooserWidgetDownFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetDownFolderCallback -> m SignalHandlerId+afterFileChooserWidgetDownFolder obj cb = connectFileChooserWidgetDownFolder obj cb SignalConnectAfter++connectFileChooserWidgetDownFolder :: (GObject a, MonadIO m) =>+                                      a -> FileChooserWidgetDownFolderCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetDownFolder obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetDownFolderCallback (fileChooserWidgetDownFolderCallbackWrapper cb)+    connectSignalFunPtr obj "down-folder" cb' after++-- signal FileChooserWidget::home-folder+type FileChooserWidgetHomeFolderCallback =+    IO ()++noFileChooserWidgetHomeFolderCallback :: Maybe FileChooserWidgetHomeFolderCallback+noFileChooserWidgetHomeFolderCallback = Nothing++type FileChooserWidgetHomeFolderCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetHomeFolderCallback :: FileChooserWidgetHomeFolderCallbackC -> IO (FunPtr FileChooserWidgetHomeFolderCallbackC)++fileChooserWidgetHomeFolderClosure :: FileChooserWidgetHomeFolderCallback -> IO Closure+fileChooserWidgetHomeFolderClosure cb = newCClosure =<< mkFileChooserWidgetHomeFolderCallback wrapped+    where wrapped = fileChooserWidgetHomeFolderCallbackWrapper cb++fileChooserWidgetHomeFolderCallbackWrapper ::+    FileChooserWidgetHomeFolderCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetHomeFolderCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetHomeFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetHomeFolderCallback -> m SignalHandlerId+onFileChooserWidgetHomeFolder obj cb = liftIO $ connectFileChooserWidgetHomeFolder obj cb SignalConnectBefore+afterFileChooserWidgetHomeFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetHomeFolderCallback -> m SignalHandlerId+afterFileChooserWidgetHomeFolder obj cb = connectFileChooserWidgetHomeFolder obj cb SignalConnectAfter++connectFileChooserWidgetHomeFolder :: (GObject a, MonadIO m) =>+                                      a -> FileChooserWidgetHomeFolderCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetHomeFolder obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetHomeFolderCallback (fileChooserWidgetHomeFolderCallbackWrapper cb)+    connectSignalFunPtr obj "home-folder" cb' after++-- signal FileChooserWidget::location-popup+type FileChooserWidgetLocationPopupCallback =+    T.Text ->+    IO ()++noFileChooserWidgetLocationPopupCallback :: Maybe FileChooserWidgetLocationPopupCallback+noFileChooserWidgetLocationPopupCallback = Nothing++type FileChooserWidgetLocationPopupCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetLocationPopupCallback :: FileChooserWidgetLocationPopupCallbackC -> IO (FunPtr FileChooserWidgetLocationPopupCallbackC)++fileChooserWidgetLocationPopupClosure :: FileChooserWidgetLocationPopupCallback -> IO Closure+fileChooserWidgetLocationPopupClosure cb = newCClosure =<< mkFileChooserWidgetLocationPopupCallback wrapped+    where wrapped = fileChooserWidgetLocationPopupCallbackWrapper cb++fileChooserWidgetLocationPopupCallbackWrapper ::+    FileChooserWidgetLocationPopupCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+fileChooserWidgetLocationPopupCallbackWrapper _cb _ path _ = do+    path' <- cstringToText path+    _cb  path'++onFileChooserWidgetLocationPopup :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationPopupCallback -> m SignalHandlerId+onFileChooserWidgetLocationPopup obj cb = liftIO $ connectFileChooserWidgetLocationPopup obj cb SignalConnectBefore+afterFileChooserWidgetLocationPopup :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationPopupCallback -> m SignalHandlerId+afterFileChooserWidgetLocationPopup obj cb = connectFileChooserWidgetLocationPopup obj cb SignalConnectAfter++connectFileChooserWidgetLocationPopup :: (GObject a, MonadIO m) =>+                                         a -> FileChooserWidgetLocationPopupCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetLocationPopup obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetLocationPopupCallback (fileChooserWidgetLocationPopupCallbackWrapper cb)+    connectSignalFunPtr obj "location-popup" cb' after++-- signal FileChooserWidget::location-popup-on-paste+type FileChooserWidgetLocationPopupOnPasteCallback =+    IO ()++noFileChooserWidgetLocationPopupOnPasteCallback :: Maybe FileChooserWidgetLocationPopupOnPasteCallback+noFileChooserWidgetLocationPopupOnPasteCallback = Nothing++type FileChooserWidgetLocationPopupOnPasteCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetLocationPopupOnPasteCallback :: FileChooserWidgetLocationPopupOnPasteCallbackC -> IO (FunPtr FileChooserWidgetLocationPopupOnPasteCallbackC)++fileChooserWidgetLocationPopupOnPasteClosure :: FileChooserWidgetLocationPopupOnPasteCallback -> IO Closure+fileChooserWidgetLocationPopupOnPasteClosure cb = newCClosure =<< mkFileChooserWidgetLocationPopupOnPasteCallback wrapped+    where wrapped = fileChooserWidgetLocationPopupOnPasteCallbackWrapper cb++fileChooserWidgetLocationPopupOnPasteCallbackWrapper ::+    FileChooserWidgetLocationPopupOnPasteCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetLocationPopupOnPasteCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetLocationPopupOnPaste :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationPopupOnPasteCallback -> m SignalHandlerId+onFileChooserWidgetLocationPopupOnPaste obj cb = liftIO $ connectFileChooserWidgetLocationPopupOnPaste obj cb SignalConnectBefore+afterFileChooserWidgetLocationPopupOnPaste :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationPopupOnPasteCallback -> m SignalHandlerId+afterFileChooserWidgetLocationPopupOnPaste obj cb = connectFileChooserWidgetLocationPopupOnPaste obj cb SignalConnectAfter++connectFileChooserWidgetLocationPopupOnPaste :: (GObject a, MonadIO m) =>+                                                a -> FileChooserWidgetLocationPopupOnPasteCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetLocationPopupOnPaste obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetLocationPopupOnPasteCallback (fileChooserWidgetLocationPopupOnPasteCallbackWrapper cb)+    connectSignalFunPtr obj "location-popup-on-paste" cb' after++-- signal FileChooserWidget::location-toggle-popup+type FileChooserWidgetLocationTogglePopupCallback =+    IO ()++noFileChooserWidgetLocationTogglePopupCallback :: Maybe FileChooserWidgetLocationTogglePopupCallback+noFileChooserWidgetLocationTogglePopupCallback = Nothing++type FileChooserWidgetLocationTogglePopupCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetLocationTogglePopupCallback :: FileChooserWidgetLocationTogglePopupCallbackC -> IO (FunPtr FileChooserWidgetLocationTogglePopupCallbackC)++fileChooserWidgetLocationTogglePopupClosure :: FileChooserWidgetLocationTogglePopupCallback -> IO Closure+fileChooserWidgetLocationTogglePopupClosure cb = newCClosure =<< mkFileChooserWidgetLocationTogglePopupCallback wrapped+    where wrapped = fileChooserWidgetLocationTogglePopupCallbackWrapper cb++fileChooserWidgetLocationTogglePopupCallbackWrapper ::+    FileChooserWidgetLocationTogglePopupCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetLocationTogglePopupCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetLocationTogglePopup :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationTogglePopupCallback -> m SignalHandlerId+onFileChooserWidgetLocationTogglePopup obj cb = liftIO $ connectFileChooserWidgetLocationTogglePopup obj cb SignalConnectBefore+afterFileChooserWidgetLocationTogglePopup :: (GObject a, MonadIO m) => a -> FileChooserWidgetLocationTogglePopupCallback -> m SignalHandlerId+afterFileChooserWidgetLocationTogglePopup obj cb = connectFileChooserWidgetLocationTogglePopup obj cb SignalConnectAfter++connectFileChooserWidgetLocationTogglePopup :: (GObject a, MonadIO m) =>+                                               a -> FileChooserWidgetLocationTogglePopupCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetLocationTogglePopup obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetLocationTogglePopupCallback (fileChooserWidgetLocationTogglePopupCallbackWrapper cb)+    connectSignalFunPtr obj "location-toggle-popup" cb' after++-- signal FileChooserWidget::places-shortcut+type FileChooserWidgetPlacesShortcutCallback =+    IO ()++noFileChooserWidgetPlacesShortcutCallback :: Maybe FileChooserWidgetPlacesShortcutCallback+noFileChooserWidgetPlacesShortcutCallback = Nothing++type FileChooserWidgetPlacesShortcutCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetPlacesShortcutCallback :: FileChooserWidgetPlacesShortcutCallbackC -> IO (FunPtr FileChooserWidgetPlacesShortcutCallbackC)++fileChooserWidgetPlacesShortcutClosure :: FileChooserWidgetPlacesShortcutCallback -> IO Closure+fileChooserWidgetPlacesShortcutClosure cb = newCClosure =<< mkFileChooserWidgetPlacesShortcutCallback wrapped+    where wrapped = fileChooserWidgetPlacesShortcutCallbackWrapper cb++fileChooserWidgetPlacesShortcutCallbackWrapper ::+    FileChooserWidgetPlacesShortcutCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetPlacesShortcutCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetPlacesShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetPlacesShortcutCallback -> m SignalHandlerId+onFileChooserWidgetPlacesShortcut obj cb = liftIO $ connectFileChooserWidgetPlacesShortcut obj cb SignalConnectBefore+afterFileChooserWidgetPlacesShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetPlacesShortcutCallback -> m SignalHandlerId+afterFileChooserWidgetPlacesShortcut obj cb = connectFileChooserWidgetPlacesShortcut obj cb SignalConnectAfter++connectFileChooserWidgetPlacesShortcut :: (GObject a, MonadIO m) =>+                                          a -> FileChooserWidgetPlacesShortcutCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetPlacesShortcut obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetPlacesShortcutCallback (fileChooserWidgetPlacesShortcutCallbackWrapper cb)+    connectSignalFunPtr obj "places-shortcut" cb' after++-- signal FileChooserWidget::quick-bookmark+type FileChooserWidgetQuickBookmarkCallback =+    Int32 ->+    IO ()++noFileChooserWidgetQuickBookmarkCallback :: Maybe FileChooserWidgetQuickBookmarkCallback+noFileChooserWidgetQuickBookmarkCallback = Nothing++type FileChooserWidgetQuickBookmarkCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetQuickBookmarkCallback :: FileChooserWidgetQuickBookmarkCallbackC -> IO (FunPtr FileChooserWidgetQuickBookmarkCallbackC)++fileChooserWidgetQuickBookmarkClosure :: FileChooserWidgetQuickBookmarkCallback -> IO Closure+fileChooserWidgetQuickBookmarkClosure cb = newCClosure =<< mkFileChooserWidgetQuickBookmarkCallback wrapped+    where wrapped = fileChooserWidgetQuickBookmarkCallbackWrapper cb++fileChooserWidgetQuickBookmarkCallbackWrapper ::+    FileChooserWidgetQuickBookmarkCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+fileChooserWidgetQuickBookmarkCallbackWrapper _cb _ bookmark_index _ = do+    _cb  bookmark_index++onFileChooserWidgetQuickBookmark :: (GObject a, MonadIO m) => a -> FileChooserWidgetQuickBookmarkCallback -> m SignalHandlerId+onFileChooserWidgetQuickBookmark obj cb = liftIO $ connectFileChooserWidgetQuickBookmark obj cb SignalConnectBefore+afterFileChooserWidgetQuickBookmark :: (GObject a, MonadIO m) => a -> FileChooserWidgetQuickBookmarkCallback -> m SignalHandlerId+afterFileChooserWidgetQuickBookmark obj cb = connectFileChooserWidgetQuickBookmark obj cb SignalConnectAfter++connectFileChooserWidgetQuickBookmark :: (GObject a, MonadIO m) =>+                                         a -> FileChooserWidgetQuickBookmarkCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetQuickBookmark obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetQuickBookmarkCallback (fileChooserWidgetQuickBookmarkCallbackWrapper cb)+    connectSignalFunPtr obj "quick-bookmark" cb' after++-- signal FileChooserWidget::recent-shortcut+type FileChooserWidgetRecentShortcutCallback =+    IO ()++noFileChooserWidgetRecentShortcutCallback :: Maybe FileChooserWidgetRecentShortcutCallback+noFileChooserWidgetRecentShortcutCallback = Nothing++type FileChooserWidgetRecentShortcutCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetRecentShortcutCallback :: FileChooserWidgetRecentShortcutCallbackC -> IO (FunPtr FileChooserWidgetRecentShortcutCallbackC)++fileChooserWidgetRecentShortcutClosure :: FileChooserWidgetRecentShortcutCallback -> IO Closure+fileChooserWidgetRecentShortcutClosure cb = newCClosure =<< mkFileChooserWidgetRecentShortcutCallback wrapped+    where wrapped = fileChooserWidgetRecentShortcutCallbackWrapper cb++fileChooserWidgetRecentShortcutCallbackWrapper ::+    FileChooserWidgetRecentShortcutCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetRecentShortcutCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetRecentShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetRecentShortcutCallback -> m SignalHandlerId+onFileChooserWidgetRecentShortcut obj cb = liftIO $ connectFileChooserWidgetRecentShortcut obj cb SignalConnectBefore+afterFileChooserWidgetRecentShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetRecentShortcutCallback -> m SignalHandlerId+afterFileChooserWidgetRecentShortcut obj cb = connectFileChooserWidgetRecentShortcut obj cb SignalConnectAfter++connectFileChooserWidgetRecentShortcut :: (GObject a, MonadIO m) =>+                                          a -> FileChooserWidgetRecentShortcutCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetRecentShortcut obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetRecentShortcutCallback (fileChooserWidgetRecentShortcutCallbackWrapper cb)+    connectSignalFunPtr obj "recent-shortcut" cb' after++-- signal FileChooserWidget::search-shortcut+type FileChooserWidgetSearchShortcutCallback =+    IO ()++noFileChooserWidgetSearchShortcutCallback :: Maybe FileChooserWidgetSearchShortcutCallback+noFileChooserWidgetSearchShortcutCallback = Nothing++type FileChooserWidgetSearchShortcutCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetSearchShortcutCallback :: FileChooserWidgetSearchShortcutCallbackC -> IO (FunPtr FileChooserWidgetSearchShortcutCallbackC)++fileChooserWidgetSearchShortcutClosure :: FileChooserWidgetSearchShortcutCallback -> IO Closure+fileChooserWidgetSearchShortcutClosure cb = newCClosure =<< mkFileChooserWidgetSearchShortcutCallback wrapped+    where wrapped = fileChooserWidgetSearchShortcutCallbackWrapper cb++fileChooserWidgetSearchShortcutCallbackWrapper ::+    FileChooserWidgetSearchShortcutCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetSearchShortcutCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetSearchShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetSearchShortcutCallback -> m SignalHandlerId+onFileChooserWidgetSearchShortcut obj cb = liftIO $ connectFileChooserWidgetSearchShortcut obj cb SignalConnectBefore+afterFileChooserWidgetSearchShortcut :: (GObject a, MonadIO m) => a -> FileChooserWidgetSearchShortcutCallback -> m SignalHandlerId+afterFileChooserWidgetSearchShortcut obj cb = connectFileChooserWidgetSearchShortcut obj cb SignalConnectAfter++connectFileChooserWidgetSearchShortcut :: (GObject a, MonadIO m) =>+                                          a -> FileChooserWidgetSearchShortcutCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetSearchShortcut obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetSearchShortcutCallback (fileChooserWidgetSearchShortcutCallbackWrapper cb)+    connectSignalFunPtr obj "search-shortcut" cb' after++-- signal FileChooserWidget::show-hidden+type FileChooserWidgetShowHiddenCallback =+    IO ()++noFileChooserWidgetShowHiddenCallback :: Maybe FileChooserWidgetShowHiddenCallback+noFileChooserWidgetShowHiddenCallback = Nothing++type FileChooserWidgetShowHiddenCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetShowHiddenCallback :: FileChooserWidgetShowHiddenCallbackC -> IO (FunPtr FileChooserWidgetShowHiddenCallbackC)++fileChooserWidgetShowHiddenClosure :: FileChooserWidgetShowHiddenCallback -> IO Closure+fileChooserWidgetShowHiddenClosure cb = newCClosure =<< mkFileChooserWidgetShowHiddenCallback wrapped+    where wrapped = fileChooserWidgetShowHiddenCallbackWrapper cb++fileChooserWidgetShowHiddenCallbackWrapper ::+    FileChooserWidgetShowHiddenCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetShowHiddenCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetShowHidden :: (GObject a, MonadIO m) => a -> FileChooserWidgetShowHiddenCallback -> m SignalHandlerId+onFileChooserWidgetShowHidden obj cb = liftIO $ connectFileChooserWidgetShowHidden obj cb SignalConnectBefore+afterFileChooserWidgetShowHidden :: (GObject a, MonadIO m) => a -> FileChooserWidgetShowHiddenCallback -> m SignalHandlerId+afterFileChooserWidgetShowHidden obj cb = connectFileChooserWidgetShowHidden obj cb SignalConnectAfter++connectFileChooserWidgetShowHidden :: (GObject a, MonadIO m) =>+                                      a -> FileChooserWidgetShowHiddenCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetShowHidden obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetShowHiddenCallback (fileChooserWidgetShowHiddenCallbackWrapper cb)+    connectSignalFunPtr obj "show-hidden" cb' after++-- signal FileChooserWidget::up-folder+type FileChooserWidgetUpFolderCallback =+    IO ()++noFileChooserWidgetUpFolderCallback :: Maybe FileChooserWidgetUpFolderCallback+noFileChooserWidgetUpFolderCallback = Nothing++type FileChooserWidgetUpFolderCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFileChooserWidgetUpFolderCallback :: FileChooserWidgetUpFolderCallbackC -> IO (FunPtr FileChooserWidgetUpFolderCallbackC)++fileChooserWidgetUpFolderClosure :: FileChooserWidgetUpFolderCallback -> IO Closure+fileChooserWidgetUpFolderClosure cb = newCClosure =<< mkFileChooserWidgetUpFolderCallback wrapped+    where wrapped = fileChooserWidgetUpFolderCallbackWrapper cb++fileChooserWidgetUpFolderCallbackWrapper ::+    FileChooserWidgetUpFolderCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fileChooserWidgetUpFolderCallbackWrapper _cb _ _ = do+    _cb ++onFileChooserWidgetUpFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetUpFolderCallback -> m SignalHandlerId+onFileChooserWidgetUpFolder obj cb = liftIO $ connectFileChooserWidgetUpFolder obj cb SignalConnectBefore+afterFileChooserWidgetUpFolder :: (GObject a, MonadIO m) => a -> FileChooserWidgetUpFolderCallback -> m SignalHandlerId+afterFileChooserWidgetUpFolder obj cb = connectFileChooserWidgetUpFolder obj cb SignalConnectAfter++connectFileChooserWidgetUpFolder :: (GObject a, MonadIO m) =>+                                    a -> FileChooserWidgetUpFolderCallback -> SignalConnectMode -> m SignalHandlerId+connectFileChooserWidgetUpFolder obj cb after = liftIO $ do+    cb' <- mkFileChooserWidgetUpFolderCallback (fileChooserWidgetUpFolderCallbackWrapper cb)+    connectSignalFunPtr obj "up-folder" cb' after++-- VVV Prop "search-mode"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFileChooserWidgetSearchMode :: (MonadIO m, FileChooserWidgetK o) => o -> m Bool+getFileChooserWidgetSearchMode obj = liftIO $ getObjectPropertyBool obj "search-mode"++setFileChooserWidgetSearchMode :: (MonadIO m, FileChooserWidgetK o) => o -> Bool -> m ()+setFileChooserWidgetSearchMode obj val = liftIO $ setObjectPropertyBool obj "search-mode" val++constructFileChooserWidgetSearchMode :: Bool -> IO ([Char], GValue)+constructFileChooserWidgetSearchMode val = constructObjectPropertyBool "search-mode" val++data FileChooserWidgetSearchModePropertyInfo+instance AttrInfo FileChooserWidgetSearchModePropertyInfo where+    type AttrAllowedOps FileChooserWidgetSearchModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FileChooserWidgetSearchModePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FileChooserWidgetSearchModePropertyInfo = FileChooserWidgetK+    type AttrGetType FileChooserWidgetSearchModePropertyInfo = Bool+    type AttrLabel FileChooserWidgetSearchModePropertyInfo = "FileChooserWidget::search-mode"+    attrGet _ = getFileChooserWidgetSearchMode+    attrSet _ = setFileChooserWidgetSearchMode+    attrConstruct _ = constructFileChooserWidgetSearchMode++-- VVV Prop "subtitle"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getFileChooserWidgetSubtitle :: (MonadIO m, FileChooserWidgetK o) => o -> m T.Text+getFileChooserWidgetSubtitle obj = liftIO $ getObjectPropertyString obj "subtitle"++data FileChooserWidgetSubtitlePropertyInfo+instance AttrInfo FileChooserWidgetSubtitlePropertyInfo where+    type AttrAllowedOps FileChooserWidgetSubtitlePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint FileChooserWidgetSubtitlePropertyInfo = (~) ()+    type AttrBaseTypeConstraint FileChooserWidgetSubtitlePropertyInfo = FileChooserWidgetK+    type AttrGetType FileChooserWidgetSubtitlePropertyInfo = T.Text+    type AttrLabel FileChooserWidgetSubtitlePropertyInfo = "FileChooserWidget::subtitle"+    attrGet _ = getFileChooserWidgetSubtitle+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList FileChooserWidget = FileChooserWidgetAttributeList+type FileChooserWidgetAttributeList = ('[ '("action", FileChooserActionPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("create-folders", FileChooserCreateFoldersPropertyInfo), '("do-overwrite-confirmation", FileChooserDoOverwriteConfirmationPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("extra-widget", FileChooserExtraWidgetPropertyInfo), '("filter", FileChooserFilterPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("local-only", FileChooserLocalOnlyPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-widget", FileChooserPreviewWidgetPropertyInfo), '("preview-widget-active", FileChooserPreviewWidgetActivePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("search-mode", FileChooserWidgetSearchModePropertyInfo), '("select-multiple", FileChooserSelectMultiplePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-hidden", FileChooserShowHiddenPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("subtitle", FileChooserWidgetSubtitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-preview-label", FileChooserUsePreviewLabelPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data FileChooserWidgetDesktopFolderSignalInfo+instance SignalInfo FileChooserWidgetDesktopFolderSignalInfo where+    type HaskellCallbackType FileChooserWidgetDesktopFolderSignalInfo = FileChooserWidgetDesktopFolderCallback+    connectSignal _ = connectFileChooserWidgetDesktopFolder++data FileChooserWidgetDownFolderSignalInfo+instance SignalInfo FileChooserWidgetDownFolderSignalInfo where+    type HaskellCallbackType FileChooserWidgetDownFolderSignalInfo = FileChooserWidgetDownFolderCallback+    connectSignal _ = connectFileChooserWidgetDownFolder++data FileChooserWidgetHomeFolderSignalInfo+instance SignalInfo FileChooserWidgetHomeFolderSignalInfo where+    type HaskellCallbackType FileChooserWidgetHomeFolderSignalInfo = FileChooserWidgetHomeFolderCallback+    connectSignal _ = connectFileChooserWidgetHomeFolder++data FileChooserWidgetLocationPopupSignalInfo+instance SignalInfo FileChooserWidgetLocationPopupSignalInfo where+    type HaskellCallbackType FileChooserWidgetLocationPopupSignalInfo = FileChooserWidgetLocationPopupCallback+    connectSignal _ = connectFileChooserWidgetLocationPopup++data FileChooserWidgetLocationPopupOnPasteSignalInfo+instance SignalInfo FileChooserWidgetLocationPopupOnPasteSignalInfo where+    type HaskellCallbackType FileChooserWidgetLocationPopupOnPasteSignalInfo = FileChooserWidgetLocationPopupOnPasteCallback+    connectSignal _ = connectFileChooserWidgetLocationPopupOnPaste++data FileChooserWidgetLocationTogglePopupSignalInfo+instance SignalInfo FileChooserWidgetLocationTogglePopupSignalInfo where+    type HaskellCallbackType FileChooserWidgetLocationTogglePopupSignalInfo = FileChooserWidgetLocationTogglePopupCallback+    connectSignal _ = connectFileChooserWidgetLocationTogglePopup++data FileChooserWidgetPlacesShortcutSignalInfo+instance SignalInfo FileChooserWidgetPlacesShortcutSignalInfo where+    type HaskellCallbackType FileChooserWidgetPlacesShortcutSignalInfo = FileChooserWidgetPlacesShortcutCallback+    connectSignal _ = connectFileChooserWidgetPlacesShortcut++data FileChooserWidgetQuickBookmarkSignalInfo+instance SignalInfo FileChooserWidgetQuickBookmarkSignalInfo where+    type HaskellCallbackType FileChooserWidgetQuickBookmarkSignalInfo = FileChooserWidgetQuickBookmarkCallback+    connectSignal _ = connectFileChooserWidgetQuickBookmark++data FileChooserWidgetRecentShortcutSignalInfo+instance SignalInfo FileChooserWidgetRecentShortcutSignalInfo where+    type HaskellCallbackType FileChooserWidgetRecentShortcutSignalInfo = FileChooserWidgetRecentShortcutCallback+    connectSignal _ = connectFileChooserWidgetRecentShortcut++data FileChooserWidgetSearchShortcutSignalInfo+instance SignalInfo FileChooserWidgetSearchShortcutSignalInfo where+    type HaskellCallbackType FileChooserWidgetSearchShortcutSignalInfo = FileChooserWidgetSearchShortcutCallback+    connectSignal _ = connectFileChooserWidgetSearchShortcut++data FileChooserWidgetShowHiddenSignalInfo+instance SignalInfo FileChooserWidgetShowHiddenSignalInfo where+    type HaskellCallbackType FileChooserWidgetShowHiddenSignalInfo = FileChooserWidgetShowHiddenCallback+    connectSignal _ = connectFileChooserWidgetShowHidden++data FileChooserWidgetUpFolderSignalInfo+instance SignalInfo FileChooserWidgetUpFolderSignalInfo where+    type HaskellCallbackType FileChooserWidgetUpFolderSignalInfo = FileChooserWidgetUpFolderCallback+    connectSignal _ = connectFileChooserWidgetUpFolder++type instance SignalList FileChooserWidget = FileChooserWidgetSignalList+type FileChooserWidgetSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("confirm-overwrite", FileChooserConfirmOverwriteSignalInfo), '("current-folder-changed", FileChooserCurrentFolderChangedSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("desktop-folder", FileChooserWidgetDesktopFolderSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("down-folder", FileChooserWidgetDownFolderSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("file-activated", FileChooserFileActivatedSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("home-folder", FileChooserWidgetHomeFolderSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("location-popup", FileChooserWidgetLocationPopupSignalInfo), '("location-popup-on-paste", FileChooserWidgetLocationPopupOnPasteSignalInfo), '("location-toggle-popup", FileChooserWidgetLocationTogglePopupSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("places-shortcut", FileChooserWidgetPlacesShortcutSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("quick-bookmark", FileChooserWidgetQuickBookmarkSignalInfo), '("realize", WidgetRealizeSignalInfo), '("recent-shortcut", FileChooserWidgetRecentShortcutSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("search-shortcut", FileChooserWidgetSearchShortcutSignalInfo), '("selection-changed", FileChooserSelectionChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("show-hidden", FileChooserWidgetShowHiddenSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("up-folder", FileChooserWidgetUpFolderSignalInfo), '("update-preview", FileChooserUpdatePreviewSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileChooserWidget::new+-- method type : Constructor+-- Args : [Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "action", argType = TInterface "Gtk" "FileChooserAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileChooserWidget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_chooser_widget_new" gtk_file_chooser_widget_new :: +    CUInt ->                                -- action : TInterface "Gtk" "FileChooserAction"+    IO (Ptr FileChooserWidget)+++fileChooserWidgetNew ::+    (MonadIO m) =>+    FileChooserAction ->                    -- action+    m FileChooserWidget+fileChooserWidgetNew action = liftIO $ do+    let action' = (fromIntegral . fromEnum) action+    result <- gtk_file_chooser_widget_new action'+    checkUnexpectedReturnNULL "gtk_file_chooser_widget_new" result+    result' <- (newObject FileChooserWidget) result+    return result'++
+ GI/Gtk/Objects/FileChooserWidget.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gtk.Objects.FileChooserWidget where++import Prelude ()+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 FileChooserWidget = FileChooserWidget (ForeignPtr FileChooserWidget)+instance GObject FileChooserWidget where+class GObject o => FileChooserWidgetK o+instance (GObject o, IsDescendantOf FileChooserWidget o) => FileChooserWidgetK o+data FileChooserWidgetSearchModePropertyInfo+data FileChooserWidgetSubtitlePropertyInfo+data FileChooserWidgetDesktopFolderSignalInfo+data FileChooserWidgetDownFolderSignalInfo+data FileChooserWidgetHomeFolderSignalInfo+data FileChooserWidgetLocationPopupSignalInfo+data FileChooserWidgetLocationPopupOnPasteSignalInfo+data FileChooserWidgetLocationTogglePopupSignalInfo+data FileChooserWidgetPlacesShortcutSignalInfo+data FileChooserWidgetQuickBookmarkSignalInfo+data FileChooserWidgetRecentShortcutSignalInfo+data FileChooserWidgetSearchShortcutSignalInfo+data FileChooserWidgetShowHiddenSignalInfo+data FileChooserWidgetUpFolderSignalInfo
+ GI/Gtk/Objects/FileFilter.hs view
@@ -0,0 +1,346 @@++{- |+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.Gtk.Objects.FileFilter+    ( ++-- * Exported types+    FileFilter(..)                          ,+    FileFilterK                             ,+    toFileFilter                            ,+    noFileFilter                            ,+++ -- * Methods+-- ** fileFilterAddCustom+    fileFilterAddCustom                     ,+++-- ** fileFilterAddMimeType+    fileFilterAddMimeType                   ,+++-- ** fileFilterAddPattern+    fileFilterAddPattern                    ,+++-- ** fileFilterAddPixbufFormats+    fileFilterAddPixbufFormats              ,+++-- ** fileFilterFilter+    fileFilterFilter                        ,+++-- ** fileFilterGetName+    fileFilterGetName                       ,+++-- ** fileFilterGetNeeded+    fileFilterGetNeeded                     ,+++-- ** fileFilterNew+    fileFilterNew                           ,+++-- ** fileFilterSetName+    fileFilterSetName                       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype FileFilter = FileFilter (ForeignPtr FileFilter)+foreign import ccall "gtk_file_filter_get_type"+    c_gtk_file_filter_get_type :: IO GType++type instance ParentTypes FileFilter = FileFilterParentTypes+type FileFilterParentTypes = '[GObject.Object, Buildable]++instance GObject FileFilter where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_file_filter_get_type+    ++class GObject o => FileFilterK o+instance (GObject o, IsDescendantOf FileFilter o) => FileFilterK o++toFileFilter :: FileFilterK o => o -> IO FileFilter+toFileFilter = unsafeCastTo FileFilter++noFileFilter :: Maybe FileFilter+noFileFilter = Nothing++type instance AttributeList FileFilter = FileFilterAttributeList+type FileFilterAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FileFilter = FileFilterSignalList+type FileFilterSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FileFilter::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FileFilter"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_new" gtk_file_filter_new :: +    IO (Ptr FileFilter)+++fileFilterNew ::+    (MonadIO m) =>+    m FileFilter+fileFilterNew  = liftIO $ do+    result <- gtk_file_filter_new+    checkUnexpectedReturnNULL "gtk_file_filter_new" result+    result' <- (newObject FileFilter) result+    return result'++-- method FileFilter::add_custom+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "needed", argType = TInterface "Gtk" "FileFilterFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "FileFilterFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing},Arg {argName = "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 = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "needed", argType = TInterface "Gtk" "FileFilterFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "FileFilterFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_add_custom" gtk_file_filter_add_custom :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    CUInt ->                                -- needed : TInterface "Gtk" "FileFilterFlags"+    FunPtr FileFilterFuncC ->               -- func : TInterface "Gtk" "FileFilterFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++fileFilterAddCustom ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    [FileFilterFlags] ->                    -- needed+    FileFilterFunc ->                       -- func+    m ()+fileFilterAddCustom _obj needed func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let needed' = gflagsToWord needed+    func' <- mkFileFilterFunc (fileFilterFuncWrapper Nothing func)+    let data_ = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    gtk_file_filter_add_custom _obj' needed' func' data_ notify+    touchManagedPtr _obj+    return ()++-- method FileFilter::add_mime_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mime_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 "gtk_file_filter_add_mime_type" gtk_file_filter_add_mime_type :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    CString ->                              -- mime_type : TBasicType TUTF8+    IO ()+++fileFilterAddMimeType ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- mime_type+    m ()+fileFilterAddMimeType _obj mime_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    mime_type' <- textToCString mime_type+    gtk_file_filter_add_mime_type _obj' mime_type'+    touchManagedPtr _obj+    freeMem mime_type'+    return ()++-- method FileFilter::add_pattern+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pattern", 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 "gtk_file_filter_add_pattern" gtk_file_filter_add_pattern :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    CString ->                              -- pattern : TBasicType TUTF8+    IO ()+++fileFilterAddPattern ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- pattern+    m ()+fileFilterAddPattern _obj pattern = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    pattern' <- textToCString pattern+    gtk_file_filter_add_pattern _obj' pattern'+    touchManagedPtr _obj+    freeMem pattern'+    return ()++-- method FileFilter::add_pixbuf_formats+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_add_pixbuf_formats" gtk_file_filter_add_pixbuf_formats :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    IO ()+++fileFilterAddPixbufFormats ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    m ()+fileFilterAddPixbufFormats _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_file_filter_add_pixbuf_formats _obj'+    touchManagedPtr _obj+    return ()++-- method FileFilter::filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_info", argType = TInterface "Gtk" "FileFilterInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_info", argType = TInterface "Gtk" "FileFilterInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_filter" gtk_file_filter_filter :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    Ptr FileFilterInfo ->                   -- filter_info : TInterface "Gtk" "FileFilterInfo"+    IO CInt+++fileFilterFilter ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    FileFilterInfo ->                       -- filter_info+    m Bool+fileFilterFilter _obj filter_info = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let filter_info' = unsafeManagedPtrGetPtr filter_info+    result <- gtk_file_filter_filter _obj' filter_info'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr filter_info+    return result'++-- method FileFilter::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_get_name" gtk_file_filter_get_name :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    IO CString+++fileFilterGetName ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    m T.Text+fileFilterGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_filter_get_name _obj'+    checkUnexpectedReturnNULL "gtk_file_filter_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FileFilter::get_needed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FileFilterFlags"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_get_needed" gtk_file_filter_get_needed :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    IO CUInt+++fileFilterGetNeeded ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    m [FileFilterFlags]+fileFilterGetNeeded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_file_filter_get_needed _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method FileFilter::set_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FileFilter", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_file_filter_set_name" gtk_file_filter_set_name :: +    Ptr FileFilter ->                       -- _obj : TInterface "Gtk" "FileFilter"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++fileFilterSetName ::+    (MonadIO m, FileFilterK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- name+    m ()+fileFilterSetName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    gtk_file_filter_set_name _obj' maybeName+    touchManagedPtr _obj+    freeMem maybeName+    return ()++
+ GI/Gtk/Objects/FileFilter.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FileFilter where++import Prelude ()+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 FileFilter = FileFilter (ForeignPtr FileFilter)+instance GObject FileFilter where+class GObject o => FileFilterK o+instance (GObject o, IsDescendantOf FileFilter o) => FileFilterK o
+ GI/Gtk/Objects/Fixed.hs view
@@ -0,0 +1,160 @@++{- |+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.Gtk.Objects.Fixed+    ( ++-- * Exported types+    Fixed(..)                               ,+    FixedK                                  ,+    toFixed                                 ,+    noFixed                                 ,+++ -- * Methods+-- ** fixedMove+    fixedMove                               ,+++-- ** fixedNew+    fixedNew                                ,+++-- ** fixedPut+    fixedPut                                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Fixed = Fixed (ForeignPtr Fixed)+foreign import ccall "gtk_fixed_get_type"+    c_gtk_fixed_get_type :: IO GType++type instance ParentTypes Fixed = FixedParentTypes+type FixedParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Fixed where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_fixed_get_type+    ++class GObject o => FixedK o+instance (GObject o, IsDescendantOf Fixed o) => FixedK o++toFixed :: FixedK o => o -> IO Fixed+toFixed = unsafeCastTo Fixed++noFixed :: Maybe Fixed+noFixed = Nothing++type instance AttributeList Fixed = FixedAttributeList+type FixedAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Fixed = FixedSignalList+type FixedSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Fixed::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Fixed"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_fixed_new" gtk_fixed_new :: +    IO (Ptr Fixed)+++fixedNew ::+    (MonadIO m) =>+    m Fixed+fixedNew  = liftIO $ do+    result <- gtk_fixed_new+    checkUnexpectedReturnNULL "gtk_fixed_new" result+    result' <- (newObject Fixed) result+    return result'++-- method Fixed::move+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Fixed", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Fixed", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_fixed_move" gtk_fixed_move :: +    Ptr Fixed ->                            -- _obj : TInterface "Gtk" "Fixed"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO ()+++fixedMove ::+    (MonadIO m, FixedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Int32 ->                                -- x+    Int32 ->                                -- y+    m ()+fixedMove _obj widget x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_fixed_move _obj' widget' x y+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method Fixed::put+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Fixed", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Fixed", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_fixed_put" gtk_fixed_put :: +    Ptr Fixed ->                            -- _obj : TInterface "Gtk" "Fixed"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO ()+++fixedPut ::+    (MonadIO m, FixedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Int32 ->                                -- x+    Int32 ->                                -- y+    m ()+fixedPut _obj widget x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_fixed_put _obj' widget' x y+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++
+ GI/Gtk/Objects/Fixed.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.Fixed where++import Prelude ()+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 Fixed = Fixed (ForeignPtr Fixed)+instance GObject Fixed where+class GObject o => FixedK o+instance (GObject o, IsDescendantOf Fixed o) => FixedK o
+ GI/Gtk/Objects/FlowBox.hs view
@@ -0,0 +1,1572 @@++{- |+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.Gtk.Objects.FlowBox+    ( ++-- * Exported types+    FlowBox(..)                             ,+    FlowBoxK                                ,+    toFlowBox                               ,+    noFlowBox                               ,+++ -- * Methods+-- ** flowBoxGetActivateOnSingleClick+    flowBoxGetActivateOnSingleClick         ,+++-- ** flowBoxGetChildAtIndex+    flowBoxGetChildAtIndex                  ,+++-- ** flowBoxGetColumnSpacing+    flowBoxGetColumnSpacing                 ,+++-- ** flowBoxGetHomogeneous+    flowBoxGetHomogeneous                   ,+++-- ** flowBoxGetMaxChildrenPerLine+    flowBoxGetMaxChildrenPerLine            ,+++-- ** flowBoxGetMinChildrenPerLine+    flowBoxGetMinChildrenPerLine            ,+++-- ** flowBoxGetRowSpacing+    flowBoxGetRowSpacing                    ,+++-- ** flowBoxGetSelectedChildren+    flowBoxGetSelectedChildren              ,+++-- ** flowBoxGetSelectionMode+    flowBoxGetSelectionMode                 ,+++-- ** flowBoxInsert+    flowBoxInsert                           ,+++-- ** flowBoxInvalidateFilter+    flowBoxInvalidateFilter                 ,+++-- ** flowBoxInvalidateSort+    flowBoxInvalidateSort                   ,+++-- ** flowBoxNew+    flowBoxNew                              ,+++-- ** flowBoxSelectAll+    flowBoxSelectAll                        ,+++-- ** flowBoxSelectChild+    flowBoxSelectChild                      ,+++-- ** flowBoxSelectedForeach+    flowBoxSelectedForeach                  ,+++-- ** flowBoxSetActivateOnSingleClick+    flowBoxSetActivateOnSingleClick         ,+++-- ** flowBoxSetColumnSpacing+    flowBoxSetColumnSpacing                 ,+++-- ** flowBoxSetFilterFunc+    flowBoxSetFilterFunc                    ,+++-- ** flowBoxSetHadjustment+    flowBoxSetHadjustment                   ,+++-- ** flowBoxSetHomogeneous+    flowBoxSetHomogeneous                   ,+++-- ** flowBoxSetMaxChildrenPerLine+    flowBoxSetMaxChildrenPerLine            ,+++-- ** flowBoxSetMinChildrenPerLine+    flowBoxSetMinChildrenPerLine            ,+++-- ** flowBoxSetRowSpacing+    flowBoxSetRowSpacing                    ,+++-- ** flowBoxSetSelectionMode+    flowBoxSetSelectionMode                 ,+++-- ** flowBoxSetSortFunc+    flowBoxSetSortFunc                      ,+++-- ** flowBoxSetVadjustment+    flowBoxSetVadjustment                   ,+++-- ** flowBoxUnselectAll+    flowBoxUnselectAll                      ,+++-- ** flowBoxUnselectChild+    flowBoxUnselectChild                    ,+++++ -- * Properties+-- ** ActivateOnSingleClick+    FlowBoxActivateOnSingleClickPropertyInfo,+    constructFlowBoxActivateOnSingleClick   ,+    getFlowBoxActivateOnSingleClick         ,+    setFlowBoxActivateOnSingleClick         ,+++-- ** ColumnSpacing+    FlowBoxColumnSpacingPropertyInfo        ,+    constructFlowBoxColumnSpacing           ,+    getFlowBoxColumnSpacing                 ,+    setFlowBoxColumnSpacing                 ,+++-- ** Homogeneous+    FlowBoxHomogeneousPropertyInfo          ,+    constructFlowBoxHomogeneous             ,+    getFlowBoxHomogeneous                   ,+    setFlowBoxHomogeneous                   ,+++-- ** MaxChildrenPerLine+    FlowBoxMaxChildrenPerLinePropertyInfo   ,+    constructFlowBoxMaxChildrenPerLine      ,+    getFlowBoxMaxChildrenPerLine            ,+    setFlowBoxMaxChildrenPerLine            ,+++-- ** MinChildrenPerLine+    FlowBoxMinChildrenPerLinePropertyInfo   ,+    constructFlowBoxMinChildrenPerLine      ,+    getFlowBoxMinChildrenPerLine            ,+    setFlowBoxMinChildrenPerLine            ,+++-- ** RowSpacing+    FlowBoxRowSpacingPropertyInfo           ,+    constructFlowBoxRowSpacing              ,+    getFlowBoxRowSpacing                    ,+    setFlowBoxRowSpacing                    ,+++-- ** SelectionMode+    FlowBoxSelectionModePropertyInfo        ,+    constructFlowBoxSelectionMode           ,+    getFlowBoxSelectionMode                 ,+    setFlowBoxSelectionMode                 ,+++++ -- * Signals+-- ** ActivateCursorChild+    FlowBoxActivateCursorChildCallback      ,+    FlowBoxActivateCursorChildCallbackC     ,+    FlowBoxActivateCursorChildSignalInfo    ,+    afterFlowBoxActivateCursorChild         ,+    flowBoxActivateCursorChildCallbackWrapper,+    flowBoxActivateCursorChildClosure       ,+    mkFlowBoxActivateCursorChildCallback    ,+    noFlowBoxActivateCursorChildCallback    ,+    onFlowBoxActivateCursorChild            ,+++-- ** ChildActivated+    FlowBoxChildActivatedCallback           ,+    FlowBoxChildActivatedCallbackC          ,+    FlowBoxChildActivatedSignalInfo         ,+    afterFlowBoxChildActivated              ,+    flowBoxChildActivatedCallbackWrapper    ,+    flowBoxChildActivatedClosure            ,+    mkFlowBoxChildActivatedCallback         ,+    noFlowBoxChildActivatedCallback         ,+    onFlowBoxChildActivated                 ,+++-- ** MoveCursor+    FlowBoxMoveCursorCallback               ,+    FlowBoxMoveCursorCallbackC              ,+    FlowBoxMoveCursorSignalInfo             ,+    afterFlowBoxMoveCursor                  ,+    flowBoxMoveCursorCallbackWrapper        ,+    flowBoxMoveCursorClosure                ,+    mkFlowBoxMoveCursorCallback             ,+    noFlowBoxMoveCursorCallback             ,+    onFlowBoxMoveCursor                     ,+++-- ** SelectAll+    FlowBoxSelectAllCallback                ,+    FlowBoxSelectAllCallbackC               ,+    FlowBoxSelectAllSignalInfo              ,+    afterFlowBoxSelectAll                   ,+    flowBoxSelectAllCallbackWrapper         ,+    flowBoxSelectAllClosure                 ,+    mkFlowBoxSelectAllCallback              ,+    noFlowBoxSelectAllCallback              ,+    onFlowBoxSelectAll                      ,+++-- ** SelectedChildrenChanged+    FlowBoxSelectedChildrenChangedCallback  ,+    FlowBoxSelectedChildrenChangedCallbackC ,+    FlowBoxSelectedChildrenChangedSignalInfo,+    afterFlowBoxSelectedChildrenChanged     ,+    flowBoxSelectedChildrenChangedCallbackWrapper,+    flowBoxSelectedChildrenChangedClosure   ,+    mkFlowBoxSelectedChildrenChangedCallback,+    noFlowBoxSelectedChildrenChangedCallback,+    onFlowBoxSelectedChildrenChanged        ,+++-- ** ToggleCursorChild+    FlowBoxToggleCursorChildCallback        ,+    FlowBoxToggleCursorChildCallbackC       ,+    FlowBoxToggleCursorChildSignalInfo      ,+    afterFlowBoxToggleCursorChild           ,+    flowBoxToggleCursorChildCallbackWrapper ,+    flowBoxToggleCursorChildClosure         ,+    mkFlowBoxToggleCursorChildCallback      ,+    noFlowBoxToggleCursorChildCallback      ,+    onFlowBoxToggleCursorChild              ,+++-- ** UnselectAll+    FlowBoxUnselectAllCallback              ,+    FlowBoxUnselectAllCallbackC             ,+    FlowBoxUnselectAllSignalInfo            ,+    afterFlowBoxUnselectAll                 ,+    flowBoxUnselectAllCallbackWrapper       ,+    flowBoxUnselectAllClosure               ,+    mkFlowBoxUnselectAllCallback            ,+    noFlowBoxUnselectAllCallback            ,+    onFlowBoxUnselectAll                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype FlowBox = FlowBox (ForeignPtr FlowBox)+foreign import ccall "gtk_flow_box_get_type"+    c_gtk_flow_box_get_type :: IO GType++type instance ParentTypes FlowBox = FlowBoxParentTypes+type FlowBoxParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject FlowBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_flow_box_get_type+    ++class GObject o => FlowBoxK o+instance (GObject o, IsDescendantOf FlowBox o) => FlowBoxK o++toFlowBox :: FlowBoxK o => o -> IO FlowBox+toFlowBox = unsafeCastTo FlowBox++noFlowBox :: Maybe FlowBox+noFlowBox = Nothing++-- signal FlowBox::activate-cursor-child+type FlowBoxActivateCursorChildCallback =+    IO ()++noFlowBoxActivateCursorChildCallback :: Maybe FlowBoxActivateCursorChildCallback+noFlowBoxActivateCursorChildCallback = Nothing++type FlowBoxActivateCursorChildCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxActivateCursorChildCallback :: FlowBoxActivateCursorChildCallbackC -> IO (FunPtr FlowBoxActivateCursorChildCallbackC)++flowBoxActivateCursorChildClosure :: FlowBoxActivateCursorChildCallback -> IO Closure+flowBoxActivateCursorChildClosure cb = newCClosure =<< mkFlowBoxActivateCursorChildCallback wrapped+    where wrapped = flowBoxActivateCursorChildCallbackWrapper cb++flowBoxActivateCursorChildCallbackWrapper ::+    FlowBoxActivateCursorChildCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxActivateCursorChildCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxActivateCursorChild :: (GObject a, MonadIO m) => a -> FlowBoxActivateCursorChildCallback -> m SignalHandlerId+onFlowBoxActivateCursorChild obj cb = liftIO $ connectFlowBoxActivateCursorChild obj cb SignalConnectBefore+afterFlowBoxActivateCursorChild :: (GObject a, MonadIO m) => a -> FlowBoxActivateCursorChildCallback -> m SignalHandlerId+afterFlowBoxActivateCursorChild obj cb = connectFlowBoxActivateCursorChild obj cb SignalConnectAfter++connectFlowBoxActivateCursorChild :: (GObject a, MonadIO m) =>+                                     a -> FlowBoxActivateCursorChildCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxActivateCursorChild obj cb after = liftIO $ do+    cb' <- mkFlowBoxActivateCursorChildCallback (flowBoxActivateCursorChildCallbackWrapper cb)+    connectSignalFunPtr obj "activate-cursor-child" cb' after++-- signal FlowBox::child-activated+type FlowBoxChildActivatedCallback =+    FlowBoxChild ->+    IO ()++noFlowBoxChildActivatedCallback :: Maybe FlowBoxChildActivatedCallback+noFlowBoxChildActivatedCallback = Nothing++type FlowBoxChildActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr FlowBoxChild ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxChildActivatedCallback :: FlowBoxChildActivatedCallbackC -> IO (FunPtr FlowBoxChildActivatedCallbackC)++flowBoxChildActivatedClosure :: FlowBoxChildActivatedCallback -> IO Closure+flowBoxChildActivatedClosure cb = newCClosure =<< mkFlowBoxChildActivatedCallback wrapped+    where wrapped = flowBoxChildActivatedCallbackWrapper cb++flowBoxChildActivatedCallbackWrapper ::+    FlowBoxChildActivatedCallback ->+    Ptr () ->+    Ptr FlowBoxChild ->+    Ptr () ->+    IO ()+flowBoxChildActivatedCallbackWrapper _cb _ child _ = do+    child' <- (newObject FlowBoxChild) child+    _cb  child'++onFlowBoxChildActivated :: (GObject a, MonadIO m) => a -> FlowBoxChildActivatedCallback -> m SignalHandlerId+onFlowBoxChildActivated obj cb = liftIO $ connectFlowBoxChildActivated obj cb SignalConnectBefore+afterFlowBoxChildActivated :: (GObject a, MonadIO m) => a -> FlowBoxChildActivatedCallback -> m SignalHandlerId+afterFlowBoxChildActivated obj cb = connectFlowBoxChildActivated obj cb SignalConnectAfter++connectFlowBoxChildActivated :: (GObject a, MonadIO m) =>+                                a -> FlowBoxChildActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxChildActivated obj cb after = liftIO $ do+    cb' <- mkFlowBoxChildActivatedCallback (flowBoxChildActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "child-activated" cb' after++-- signal FlowBox::move-cursor+type FlowBoxMoveCursorCallback =+    MovementStep ->+    Int32 ->+    IO Bool++noFlowBoxMoveCursorCallback :: Maybe FlowBoxMoveCursorCallback+noFlowBoxMoveCursorCallback = Nothing++type FlowBoxMoveCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkFlowBoxMoveCursorCallback :: FlowBoxMoveCursorCallbackC -> IO (FunPtr FlowBoxMoveCursorCallbackC)++flowBoxMoveCursorClosure :: FlowBoxMoveCursorCallback -> IO Closure+flowBoxMoveCursorClosure cb = newCClosure =<< mkFlowBoxMoveCursorCallback wrapped+    where wrapped = flowBoxMoveCursorCallbackWrapper cb++flowBoxMoveCursorCallbackWrapper ::+    FlowBoxMoveCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    Ptr () ->+    IO CInt+flowBoxMoveCursorCallbackWrapper _cb _ step count _ = do+    let step' = (toEnum . fromIntegral) step+    result <- _cb  step' count+    let result' = (fromIntegral . fromEnum) result+    return result'++onFlowBoxMoveCursor :: (GObject a, MonadIO m) => a -> FlowBoxMoveCursorCallback -> m SignalHandlerId+onFlowBoxMoveCursor obj cb = liftIO $ connectFlowBoxMoveCursor obj cb SignalConnectBefore+afterFlowBoxMoveCursor :: (GObject a, MonadIO m) => a -> FlowBoxMoveCursorCallback -> m SignalHandlerId+afterFlowBoxMoveCursor obj cb = connectFlowBoxMoveCursor obj cb SignalConnectAfter++connectFlowBoxMoveCursor :: (GObject a, MonadIO m) =>+                            a -> FlowBoxMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxMoveCursor obj cb after = liftIO $ do+    cb' <- mkFlowBoxMoveCursorCallback (flowBoxMoveCursorCallbackWrapper cb)+    connectSignalFunPtr obj "move-cursor" cb' after++-- signal FlowBox::select-all+type FlowBoxSelectAllCallback =+    IO ()++noFlowBoxSelectAllCallback :: Maybe FlowBoxSelectAllCallback+noFlowBoxSelectAllCallback = Nothing++type FlowBoxSelectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxSelectAllCallback :: FlowBoxSelectAllCallbackC -> IO (FunPtr FlowBoxSelectAllCallbackC)++flowBoxSelectAllClosure :: FlowBoxSelectAllCallback -> IO Closure+flowBoxSelectAllClosure cb = newCClosure =<< mkFlowBoxSelectAllCallback wrapped+    where wrapped = flowBoxSelectAllCallbackWrapper cb++flowBoxSelectAllCallbackWrapper ::+    FlowBoxSelectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxSelectAllCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxSelectAll :: (GObject a, MonadIO m) => a -> FlowBoxSelectAllCallback -> m SignalHandlerId+onFlowBoxSelectAll obj cb = liftIO $ connectFlowBoxSelectAll obj cb SignalConnectBefore+afterFlowBoxSelectAll :: (GObject a, MonadIO m) => a -> FlowBoxSelectAllCallback -> m SignalHandlerId+afterFlowBoxSelectAll obj cb = connectFlowBoxSelectAll obj cb SignalConnectAfter++connectFlowBoxSelectAll :: (GObject a, MonadIO m) =>+                           a -> FlowBoxSelectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxSelectAll obj cb after = liftIO $ do+    cb' <- mkFlowBoxSelectAllCallback (flowBoxSelectAllCallbackWrapper cb)+    connectSignalFunPtr obj "select-all" cb' after++-- signal FlowBox::selected-children-changed+type FlowBoxSelectedChildrenChangedCallback =+    IO ()++noFlowBoxSelectedChildrenChangedCallback :: Maybe FlowBoxSelectedChildrenChangedCallback+noFlowBoxSelectedChildrenChangedCallback = Nothing++type FlowBoxSelectedChildrenChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxSelectedChildrenChangedCallback :: FlowBoxSelectedChildrenChangedCallbackC -> IO (FunPtr FlowBoxSelectedChildrenChangedCallbackC)++flowBoxSelectedChildrenChangedClosure :: FlowBoxSelectedChildrenChangedCallback -> IO Closure+flowBoxSelectedChildrenChangedClosure cb = newCClosure =<< mkFlowBoxSelectedChildrenChangedCallback wrapped+    where wrapped = flowBoxSelectedChildrenChangedCallbackWrapper cb++flowBoxSelectedChildrenChangedCallbackWrapper ::+    FlowBoxSelectedChildrenChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxSelectedChildrenChangedCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxSelectedChildrenChanged :: (GObject a, MonadIO m) => a -> FlowBoxSelectedChildrenChangedCallback -> m SignalHandlerId+onFlowBoxSelectedChildrenChanged obj cb = liftIO $ connectFlowBoxSelectedChildrenChanged obj cb SignalConnectBefore+afterFlowBoxSelectedChildrenChanged :: (GObject a, MonadIO m) => a -> FlowBoxSelectedChildrenChangedCallback -> m SignalHandlerId+afterFlowBoxSelectedChildrenChanged obj cb = connectFlowBoxSelectedChildrenChanged obj cb SignalConnectAfter++connectFlowBoxSelectedChildrenChanged :: (GObject a, MonadIO m) =>+                                         a -> FlowBoxSelectedChildrenChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxSelectedChildrenChanged obj cb after = liftIO $ do+    cb' <- mkFlowBoxSelectedChildrenChangedCallback (flowBoxSelectedChildrenChangedCallbackWrapper cb)+    connectSignalFunPtr obj "selected-children-changed" cb' after++-- signal FlowBox::toggle-cursor-child+type FlowBoxToggleCursorChildCallback =+    IO ()++noFlowBoxToggleCursorChildCallback :: Maybe FlowBoxToggleCursorChildCallback+noFlowBoxToggleCursorChildCallback = Nothing++type FlowBoxToggleCursorChildCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxToggleCursorChildCallback :: FlowBoxToggleCursorChildCallbackC -> IO (FunPtr FlowBoxToggleCursorChildCallbackC)++flowBoxToggleCursorChildClosure :: FlowBoxToggleCursorChildCallback -> IO Closure+flowBoxToggleCursorChildClosure cb = newCClosure =<< mkFlowBoxToggleCursorChildCallback wrapped+    where wrapped = flowBoxToggleCursorChildCallbackWrapper cb++flowBoxToggleCursorChildCallbackWrapper ::+    FlowBoxToggleCursorChildCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxToggleCursorChildCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxToggleCursorChild :: (GObject a, MonadIO m) => a -> FlowBoxToggleCursorChildCallback -> m SignalHandlerId+onFlowBoxToggleCursorChild obj cb = liftIO $ connectFlowBoxToggleCursorChild obj cb SignalConnectBefore+afterFlowBoxToggleCursorChild :: (GObject a, MonadIO m) => a -> FlowBoxToggleCursorChildCallback -> m SignalHandlerId+afterFlowBoxToggleCursorChild obj cb = connectFlowBoxToggleCursorChild obj cb SignalConnectAfter++connectFlowBoxToggleCursorChild :: (GObject a, MonadIO m) =>+                                   a -> FlowBoxToggleCursorChildCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxToggleCursorChild obj cb after = liftIO $ do+    cb' <- mkFlowBoxToggleCursorChildCallback (flowBoxToggleCursorChildCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-cursor-child" cb' after++-- signal FlowBox::unselect-all+type FlowBoxUnselectAllCallback =+    IO ()++noFlowBoxUnselectAllCallback :: Maybe FlowBoxUnselectAllCallback+noFlowBoxUnselectAllCallback = Nothing++type FlowBoxUnselectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxUnselectAllCallback :: FlowBoxUnselectAllCallbackC -> IO (FunPtr FlowBoxUnselectAllCallbackC)++flowBoxUnselectAllClosure :: FlowBoxUnselectAllCallback -> IO Closure+flowBoxUnselectAllClosure cb = newCClosure =<< mkFlowBoxUnselectAllCallback wrapped+    where wrapped = flowBoxUnselectAllCallbackWrapper cb++flowBoxUnselectAllCallbackWrapper ::+    FlowBoxUnselectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxUnselectAllCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxUnselectAll :: (GObject a, MonadIO m) => a -> FlowBoxUnselectAllCallback -> m SignalHandlerId+onFlowBoxUnselectAll obj cb = liftIO $ connectFlowBoxUnselectAll obj cb SignalConnectBefore+afterFlowBoxUnselectAll :: (GObject a, MonadIO m) => a -> FlowBoxUnselectAllCallback -> m SignalHandlerId+afterFlowBoxUnselectAll obj cb = connectFlowBoxUnselectAll obj cb SignalConnectAfter++connectFlowBoxUnselectAll :: (GObject a, MonadIO m) =>+                             a -> FlowBoxUnselectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxUnselectAll obj cb after = liftIO $ do+    cb' <- mkFlowBoxUnselectAllCallback (flowBoxUnselectAllCallbackWrapper cb)+    connectSignalFunPtr obj "unselect-all" cb' after++-- VVV Prop "activate-on-single-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxActivateOnSingleClick :: (MonadIO m, FlowBoxK o) => o -> m Bool+getFlowBoxActivateOnSingleClick obj = liftIO $ getObjectPropertyBool obj "activate-on-single-click"++setFlowBoxActivateOnSingleClick :: (MonadIO m, FlowBoxK o) => o -> Bool -> m ()+setFlowBoxActivateOnSingleClick obj val = liftIO $ setObjectPropertyBool obj "activate-on-single-click" val++constructFlowBoxActivateOnSingleClick :: Bool -> IO ([Char], GValue)+constructFlowBoxActivateOnSingleClick val = constructObjectPropertyBool "activate-on-single-click" val++data FlowBoxActivateOnSingleClickPropertyInfo+instance AttrInfo FlowBoxActivateOnSingleClickPropertyInfo where+    type AttrAllowedOps FlowBoxActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxActivateOnSingleClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FlowBoxActivateOnSingleClickPropertyInfo = FlowBoxK+    type AttrGetType FlowBoxActivateOnSingleClickPropertyInfo = Bool+    type AttrLabel FlowBoxActivateOnSingleClickPropertyInfo = "FlowBox::activate-on-single-click"+    attrGet _ = getFlowBoxActivateOnSingleClick+    attrSet _ = setFlowBoxActivateOnSingleClick+    attrConstruct _ = constructFlowBoxActivateOnSingleClick++-- VVV Prop "column-spacing"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxColumnSpacing :: (MonadIO m, FlowBoxK o) => o -> m Word32+getFlowBoxColumnSpacing obj = liftIO $ getObjectPropertyCUInt obj "column-spacing"++setFlowBoxColumnSpacing :: (MonadIO m, FlowBoxK o) => o -> Word32 -> m ()+setFlowBoxColumnSpacing obj val = liftIO $ setObjectPropertyCUInt obj "column-spacing" val++constructFlowBoxColumnSpacing :: Word32 -> IO ([Char], GValue)+constructFlowBoxColumnSpacing val = constructObjectPropertyCUInt "column-spacing" val++data FlowBoxColumnSpacingPropertyInfo+instance AttrInfo FlowBoxColumnSpacingPropertyInfo where+    type AttrAllowedOps FlowBoxColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxColumnSpacingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint FlowBoxColumnSpacingPropertyInfo = FlowBoxK+    type AttrGetType FlowBoxColumnSpacingPropertyInfo = Word32+    type AttrLabel FlowBoxColumnSpacingPropertyInfo = "FlowBox::column-spacing"+    attrGet _ = getFlowBoxColumnSpacing+    attrSet _ = setFlowBoxColumnSpacing+    attrConstruct _ = constructFlowBoxColumnSpacing++-- VVV Prop "homogeneous"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxHomogeneous :: (MonadIO m, FlowBoxK o) => o -> m Bool+getFlowBoxHomogeneous obj = liftIO $ getObjectPropertyBool obj "homogeneous"++setFlowBoxHomogeneous :: (MonadIO m, FlowBoxK o) => o -> Bool -> m ()+setFlowBoxHomogeneous obj val = liftIO $ setObjectPropertyBool obj "homogeneous" val++constructFlowBoxHomogeneous :: Bool -> IO ([Char], GValue)+constructFlowBoxHomogeneous val = constructObjectPropertyBool "homogeneous" val++data FlowBoxHomogeneousPropertyInfo+instance AttrInfo FlowBoxHomogeneousPropertyInfo where+    type AttrAllowedOps FlowBoxHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxHomogeneousPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FlowBoxHomogeneousPropertyInfo = FlowBoxK+    type AttrGetType FlowBoxHomogeneousPropertyInfo = Bool+    type AttrLabel FlowBoxHomogeneousPropertyInfo = "FlowBox::homogeneous"+    attrGet _ = getFlowBoxHomogeneous+    attrSet _ = setFlowBoxHomogeneous+    attrConstruct _ = constructFlowBoxHomogeneous++-- VVV Prop "max-children-per-line"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxMaxChildrenPerLine :: (MonadIO m, FlowBoxK o) => o -> m Word32+getFlowBoxMaxChildrenPerLine obj = liftIO $ getObjectPropertyCUInt obj "max-children-per-line"++setFlowBoxMaxChildrenPerLine :: (MonadIO m, FlowBoxK o) => o -> Word32 -> m ()+setFlowBoxMaxChildrenPerLine obj val = liftIO $ setObjectPropertyCUInt obj "max-children-per-line" val++constructFlowBoxMaxChildrenPerLine :: Word32 -> IO ([Char], GValue)+constructFlowBoxMaxChildrenPerLine val = constructObjectPropertyCUInt "max-children-per-line" val++data FlowBoxMaxChildrenPerLinePropertyInfo+instance AttrInfo FlowBoxMaxChildrenPerLinePropertyInfo where+    type AttrAllowedOps FlowBoxMaxChildrenPerLinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxMaxChildrenPerLinePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint FlowBoxMaxChildrenPerLinePropertyInfo = FlowBoxK+    type AttrGetType FlowBoxMaxChildrenPerLinePropertyInfo = Word32+    type AttrLabel FlowBoxMaxChildrenPerLinePropertyInfo = "FlowBox::max-children-per-line"+    attrGet _ = getFlowBoxMaxChildrenPerLine+    attrSet _ = setFlowBoxMaxChildrenPerLine+    attrConstruct _ = constructFlowBoxMaxChildrenPerLine++-- VVV Prop "min-children-per-line"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxMinChildrenPerLine :: (MonadIO m, FlowBoxK o) => o -> m Word32+getFlowBoxMinChildrenPerLine obj = liftIO $ getObjectPropertyCUInt obj "min-children-per-line"++setFlowBoxMinChildrenPerLine :: (MonadIO m, FlowBoxK o) => o -> Word32 -> m ()+setFlowBoxMinChildrenPerLine obj val = liftIO $ setObjectPropertyCUInt obj "min-children-per-line" val++constructFlowBoxMinChildrenPerLine :: Word32 -> IO ([Char], GValue)+constructFlowBoxMinChildrenPerLine val = constructObjectPropertyCUInt "min-children-per-line" val++data FlowBoxMinChildrenPerLinePropertyInfo+instance AttrInfo FlowBoxMinChildrenPerLinePropertyInfo where+    type AttrAllowedOps FlowBoxMinChildrenPerLinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxMinChildrenPerLinePropertyInfo = (~) Word32+    type AttrBaseTypeConstraint FlowBoxMinChildrenPerLinePropertyInfo = FlowBoxK+    type AttrGetType FlowBoxMinChildrenPerLinePropertyInfo = Word32+    type AttrLabel FlowBoxMinChildrenPerLinePropertyInfo = "FlowBox::min-children-per-line"+    attrGet _ = getFlowBoxMinChildrenPerLine+    attrSet _ = setFlowBoxMinChildrenPerLine+    attrConstruct _ = constructFlowBoxMinChildrenPerLine++-- VVV Prop "row-spacing"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxRowSpacing :: (MonadIO m, FlowBoxK o) => o -> m Word32+getFlowBoxRowSpacing obj = liftIO $ getObjectPropertyCUInt obj "row-spacing"++setFlowBoxRowSpacing :: (MonadIO m, FlowBoxK o) => o -> Word32 -> m ()+setFlowBoxRowSpacing obj val = liftIO $ setObjectPropertyCUInt obj "row-spacing" val++constructFlowBoxRowSpacing :: Word32 -> IO ([Char], GValue)+constructFlowBoxRowSpacing val = constructObjectPropertyCUInt "row-spacing" val++data FlowBoxRowSpacingPropertyInfo+instance AttrInfo FlowBoxRowSpacingPropertyInfo where+    type AttrAllowedOps FlowBoxRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxRowSpacingPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint FlowBoxRowSpacingPropertyInfo = FlowBoxK+    type AttrGetType FlowBoxRowSpacingPropertyInfo = Word32+    type AttrLabel FlowBoxRowSpacingPropertyInfo = "FlowBox::row-spacing"+    attrGet _ = getFlowBoxRowSpacing+    attrSet _ = setFlowBoxRowSpacing+    attrConstruct _ = constructFlowBoxRowSpacing++-- VVV Prop "selection-mode"+   -- Type: TInterface "Gtk" "SelectionMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getFlowBoxSelectionMode :: (MonadIO m, FlowBoxK o) => o -> m SelectionMode+getFlowBoxSelectionMode obj = liftIO $ getObjectPropertyEnum obj "selection-mode"++setFlowBoxSelectionMode :: (MonadIO m, FlowBoxK o) => o -> SelectionMode -> m ()+setFlowBoxSelectionMode obj val = liftIO $ setObjectPropertyEnum obj "selection-mode" val++constructFlowBoxSelectionMode :: SelectionMode -> IO ([Char], GValue)+constructFlowBoxSelectionMode val = constructObjectPropertyEnum "selection-mode" val++data FlowBoxSelectionModePropertyInfo+instance AttrInfo FlowBoxSelectionModePropertyInfo where+    type AttrAllowedOps FlowBoxSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FlowBoxSelectionModePropertyInfo = (~) SelectionMode+    type AttrBaseTypeConstraint FlowBoxSelectionModePropertyInfo = FlowBoxK+    type AttrGetType FlowBoxSelectionModePropertyInfo = SelectionMode+    type AttrLabel FlowBoxSelectionModePropertyInfo = "FlowBox::selection-mode"+    attrGet _ = getFlowBoxSelectionMode+    attrSet _ = setFlowBoxSelectionMode+    attrConstruct _ = constructFlowBoxSelectionMode++type instance AttributeList FlowBox = FlowBoxAttributeList+type FlowBoxAttributeList = ('[ '("activate-on-single-click", FlowBoxActivateOnSingleClickPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-spacing", FlowBoxColumnSpacingPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", FlowBoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-children-per-line", FlowBoxMaxChildrenPerLinePropertyInfo), '("min-children-per-line", FlowBoxMinChildrenPerLinePropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-spacing", FlowBoxRowSpacingPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selection-mode", FlowBoxSelectionModePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data FlowBoxActivateCursorChildSignalInfo+instance SignalInfo FlowBoxActivateCursorChildSignalInfo where+    type HaskellCallbackType FlowBoxActivateCursorChildSignalInfo = FlowBoxActivateCursorChildCallback+    connectSignal _ = connectFlowBoxActivateCursorChild++data FlowBoxChildActivatedSignalInfo+instance SignalInfo FlowBoxChildActivatedSignalInfo where+    type HaskellCallbackType FlowBoxChildActivatedSignalInfo = FlowBoxChildActivatedCallback+    connectSignal _ = connectFlowBoxChildActivated++data FlowBoxMoveCursorSignalInfo+instance SignalInfo FlowBoxMoveCursorSignalInfo where+    type HaskellCallbackType FlowBoxMoveCursorSignalInfo = FlowBoxMoveCursorCallback+    connectSignal _ = connectFlowBoxMoveCursor++data FlowBoxSelectAllSignalInfo+instance SignalInfo FlowBoxSelectAllSignalInfo where+    type HaskellCallbackType FlowBoxSelectAllSignalInfo = FlowBoxSelectAllCallback+    connectSignal _ = connectFlowBoxSelectAll++data FlowBoxSelectedChildrenChangedSignalInfo+instance SignalInfo FlowBoxSelectedChildrenChangedSignalInfo where+    type HaskellCallbackType FlowBoxSelectedChildrenChangedSignalInfo = FlowBoxSelectedChildrenChangedCallback+    connectSignal _ = connectFlowBoxSelectedChildrenChanged++data FlowBoxToggleCursorChildSignalInfo+instance SignalInfo FlowBoxToggleCursorChildSignalInfo where+    type HaskellCallbackType FlowBoxToggleCursorChildSignalInfo = FlowBoxToggleCursorChildCallback+    connectSignal _ = connectFlowBoxToggleCursorChild++data FlowBoxUnselectAllSignalInfo+instance SignalInfo FlowBoxUnselectAllSignalInfo where+    type HaskellCallbackType FlowBoxUnselectAllSignalInfo = FlowBoxUnselectAllCallback+    connectSignal _ = connectFlowBoxUnselectAll++type instance SignalList FlowBox = FlowBoxSignalList+type FlowBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-cursor-child", FlowBoxActivateCursorChildSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-activated", FlowBoxChildActivatedSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", FlowBoxMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select-all", FlowBoxSelectAllSignalInfo), '("selected-children-changed", FlowBoxSelectedChildrenChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-cursor-child", FlowBoxToggleCursorChildSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("unselect-all", FlowBoxUnselectAllSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FlowBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FlowBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_new" gtk_flow_box_new :: +    IO (Ptr FlowBox)+++flowBoxNew ::+    (MonadIO m) =>+    m FlowBox+flowBoxNew  = liftIO $ do+    result <- gtk_flow_box_new+    checkUnexpectedReturnNULL "gtk_flow_box_new" result+    result' <- (newObject FlowBox) result+    return result'++-- method FlowBox::get_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_activate_on_single_click" gtk_flow_box_get_activate_on_single_click :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO CInt+++flowBoxGetActivateOnSingleClick ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Bool+flowBoxGetActivateOnSingleClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_activate_on_single_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FlowBox::get_child_at_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FlowBoxChild"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_child_at_index" gtk_flow_box_get_child_at_index :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Int32 ->                                -- idx : TBasicType TInt32+    IO (Ptr FlowBoxChild)+++flowBoxGetChildAtIndex ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- idx+    m FlowBoxChild+flowBoxGetChildAtIndex _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_child_at_index _obj' idx+    checkUnexpectedReturnNULL "gtk_flow_box_get_child_at_index" result+    result' <- (newObject FlowBoxChild) result+    touchManagedPtr _obj+    return result'++-- method FlowBox::get_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_column_spacing" gtk_flow_box_get_column_spacing :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO Word32+++flowBoxGetColumnSpacing ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Word32+flowBoxGetColumnSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_column_spacing _obj'+    touchManagedPtr _obj+    return result++-- method FlowBox::get_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_homogeneous" gtk_flow_box_get_homogeneous :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO CInt+++flowBoxGetHomogeneous ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Bool+flowBoxGetHomogeneous _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_homogeneous _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FlowBox::get_max_children_per_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_max_children_per_line" gtk_flow_box_get_max_children_per_line :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO Word32+++flowBoxGetMaxChildrenPerLine ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Word32+flowBoxGetMaxChildrenPerLine _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_max_children_per_line _obj'+    touchManagedPtr _obj+    return result++-- method FlowBox::get_min_children_per_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_min_children_per_line" gtk_flow_box_get_min_children_per_line :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO Word32+++flowBoxGetMinChildrenPerLine ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Word32+flowBoxGetMinChildrenPerLine _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_min_children_per_line _obj'+    touchManagedPtr _obj+    return result++-- method FlowBox::get_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_row_spacing" gtk_flow_box_get_row_spacing :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO Word32+++flowBoxGetRowSpacing ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m Word32+flowBoxGetRowSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_row_spacing _obj'+    touchManagedPtr _obj+    return result++-- method FlowBox::get_selected_children+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "FlowBoxChild")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_selected_children" gtk_flow_box_get_selected_children :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO (Ptr (GList (Ptr FlowBoxChild)))+++flowBoxGetSelectedChildren ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m [FlowBoxChild]+flowBoxGetSelectedChildren _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_selected_children _obj'+    checkUnexpectedReturnNULL "gtk_flow_box_get_selected_children" result+    result' <- unpackGList result+    result'' <- mapM (newObject FlowBoxChild) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method FlowBox::get_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SelectionMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_get_selection_mode" gtk_flow_box_get_selection_mode :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO CUInt+++flowBoxGetSelectionMode ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m SelectionMode+flowBoxGetSelectionMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_get_selection_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FlowBox::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", 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 "gtk_flow_box_insert" gtk_flow_box_insert :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++flowBoxInsert ::+    (MonadIO m, FlowBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Int32 ->                                -- position+    m ()+flowBoxInsert _obj widget position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_flow_box_insert _obj' widget' position+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method FlowBox::invalidate_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_invalidate_filter" gtk_flow_box_invalidate_filter :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO ()+++flowBoxInvalidateFilter ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m ()+flowBoxInvalidateFilter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_invalidate_filter _obj'+    touchManagedPtr _obj+    return ()++-- method FlowBox::invalidate_sort+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_invalidate_sort" gtk_flow_box_invalidate_sort :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO ()+++flowBoxInvalidateSort ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m ()+flowBoxInvalidateSort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_invalidate_sort _obj'+    touchManagedPtr _obj+    return ()++-- method FlowBox::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_select_all" gtk_flow_box_select_all :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO ()+++flowBoxSelectAll ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m ()+flowBoxSelectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_select_all _obj'+    touchManagedPtr _obj+    return ()++-- method FlowBox::select_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_select_child" gtk_flow_box_select_child :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Ptr FlowBoxChild ->                     -- child : TInterface "Gtk" "FlowBoxChild"+    IO ()+++flowBoxSelectChild ::+    (MonadIO m, FlowBoxK a, FlowBoxChildK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+flowBoxSelectChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_flow_box_select_child _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method FlowBox::selected_foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "FlowBoxForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, 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 "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "FlowBoxForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_selected_foreach" gtk_flow_box_selected_foreach :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    FunPtr FlowBoxForeachFuncC ->           -- func : TInterface "Gtk" "FlowBoxForeachFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++flowBoxSelectedForeach ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    FlowBoxForeachFunc ->                   -- func+    m ()+flowBoxSelectedForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkFlowBoxForeachFunc (flowBoxForeachFuncWrapper Nothing func)+    let data_ = nullPtr+    gtk_flow_box_selected_foreach _obj' func' data_+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", 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 "gtk_flow_box_set_activate_on_single_click" gtk_flow_box_set_activate_on_single_click :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    CInt ->                                 -- single : TBasicType TBoolean+    IO ()+++flowBoxSetActivateOnSingleClick ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- single+    m ()+flowBoxSetActivateOnSingleClick _obj single = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let single' = (fromIntegral . fromEnum) single+    gtk_flow_box_set_activate_on_single_click _obj' single'+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_flow_box_set_column_spacing" gtk_flow_box_set_column_spacing :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Word32 ->                               -- spacing : TBasicType TUInt32+    IO ()+++flowBoxSetColumnSpacing ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- spacing+    m ()+flowBoxSetColumnSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_set_column_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_filter_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_func", argType = TInterface "Gtk" "FlowBoxFilterFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_func", argType = TInterface "Gtk" "FlowBoxFilterFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_set_filter_func" gtk_flow_box_set_filter_func :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    FunPtr FlowBoxFilterFuncC ->            -- filter_func : TInterface "Gtk" "FlowBoxFilterFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++flowBoxSetFilterFunc ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Maybe (FlowBoxFilterFunc) ->            -- filter_func+    m ()+flowBoxSetFilterFunc _obj filter_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter_func <- case filter_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFilter_func -> do+            jFilter_func' <- mkFlowBoxFilterFunc (flowBoxFilterFuncWrapper Nothing jFilter_func)+            return jFilter_func'+    let user_data = castFunPtrToPtr maybeFilter_func+    let destroy = safeFreeFunPtrPtr+    gtk_flow_box_set_filter_func _obj' maybeFilter_func user_data destroy+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_set_hadjustment" gtk_flow_box_set_hadjustment :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++flowBoxSetHadjustment ::+    (MonadIO m, FlowBoxK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+flowBoxSetHadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_flow_box_set_hadjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method FlowBox::set_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", 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 "gtk_flow_box_set_homogeneous" gtk_flow_box_set_homogeneous :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    CInt ->                                 -- homogeneous : TBasicType TBoolean+    IO ()+++flowBoxSetHomogeneous ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- homogeneous+    m ()+flowBoxSetHomogeneous _obj homogeneous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    gtk_flow_box_set_homogeneous _obj' homogeneous'+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_max_children_per_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_children", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_children", 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 "gtk_flow_box_set_max_children_per_line" gtk_flow_box_set_max_children_per_line :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Word32 ->                               -- n_children : TBasicType TUInt32+    IO ()+++flowBoxSetMaxChildrenPerLine ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- n_children+    m ()+flowBoxSetMaxChildrenPerLine _obj n_children = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_set_max_children_per_line _obj' n_children+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_min_children_per_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_children", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_children", 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 "gtk_flow_box_set_min_children_per_line" gtk_flow_box_set_min_children_per_line :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Word32 ->                               -- n_children : TBasicType TUInt32+    IO ()+++flowBoxSetMinChildrenPerLine ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- n_children+    m ()+flowBoxSetMinChildrenPerLine _obj n_children = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_set_min_children_per_line _obj' n_children+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_flow_box_set_row_spacing" gtk_flow_box_set_row_spacing :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Word32 ->                               -- spacing : TBasicType TUInt32+    IO ()+++flowBoxSetRowSpacing ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- spacing+    m ()+flowBoxSetRowSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_set_row_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_set_selection_mode" gtk_flow_box_set_selection_mode :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    CUInt ->                                -- mode : TInterface "Gtk" "SelectionMode"+    IO ()+++flowBoxSetSelectionMode ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    SelectionMode ->                        -- mode+    m ()+flowBoxSetSelectionMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_flow_box_set_selection_mode _obj' mode'+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "FlowBoxSortFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "FlowBoxSortFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_set_sort_func" gtk_flow_box_set_sort_func :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    FunPtr FlowBoxSortFuncC ->              -- sort_func : TInterface "Gtk" "FlowBoxSortFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++flowBoxSetSortFunc ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    Maybe (FlowBoxSortFunc) ->              -- sort_func+    m ()+flowBoxSetSortFunc _obj sort_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSort_func <- case sort_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jSort_func -> do+            jSort_func' <- mkFlowBoxSortFunc (flowBoxSortFuncWrapper Nothing jSort_func)+            return jSort_func'+    let user_data = castFunPtrToPtr maybeSort_func+    let destroy = safeFreeFunPtrPtr+    gtk_flow_box_set_sort_func _obj' maybeSort_func user_data destroy+    touchManagedPtr _obj+    return ()++-- method FlowBox::set_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_set_vadjustment" gtk_flow_box_set_vadjustment :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++flowBoxSetVadjustment ::+    (MonadIO m, FlowBoxK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+flowBoxSetVadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_flow_box_set_vadjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method FlowBox::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_unselect_all" gtk_flow_box_unselect_all :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    IO ()+++flowBoxUnselectAll ::+    (MonadIO m, FlowBoxK a) =>+    a ->                                    -- _obj+    m ()+flowBoxUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method FlowBox::unselect_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_unselect_child" gtk_flow_box_unselect_child :: +    Ptr FlowBox ->                          -- _obj : TInterface "Gtk" "FlowBox"+    Ptr FlowBoxChild ->                     -- child : TInterface "Gtk" "FlowBoxChild"+    IO ()+++flowBoxUnselectChild ::+    (MonadIO m, FlowBoxK a, FlowBoxChildK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+flowBoxUnselectChild _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_flow_box_unselect_child _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++
+ GI/Gtk/Objects/FlowBox.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gtk.Objects.FlowBox where++import Prelude ()+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 FlowBox = FlowBox (ForeignPtr FlowBox)+instance GObject FlowBox where+class GObject o => FlowBoxK o+instance (GObject o, IsDescendantOf FlowBox o) => FlowBoxK o+data FlowBoxActivateOnSingleClickPropertyInfo+data FlowBoxColumnSpacingPropertyInfo+data FlowBoxHomogeneousPropertyInfo+data FlowBoxMaxChildrenPerLinePropertyInfo+data FlowBoxMinChildrenPerLinePropertyInfo+data FlowBoxRowSpacingPropertyInfo+data FlowBoxSelectionModePropertyInfo+data FlowBoxActivateCursorChildSignalInfo+data FlowBoxChildActivatedSignalInfo+data FlowBoxMoveCursorSignalInfo+data FlowBoxSelectAllSignalInfo+data FlowBoxSelectedChildrenChangedSignalInfo+data FlowBoxToggleCursorChildSignalInfo+data FlowBoxUnselectAllSignalInfo
+ GI/Gtk/Objects/FlowBoxAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.FlowBoxAccessible+    ( ++-- * Exported types+    FlowBoxAccessible(..)                   ,+    FlowBoxAccessibleK                      ,+    toFlowBoxAccessible                     ,+    noFlowBoxAccessible                     ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FlowBoxAccessible = FlowBoxAccessible (ForeignPtr FlowBoxAccessible)+foreign import ccall "gtk_flow_box_accessible_get_type"+    c_gtk_flow_box_accessible_get_type :: IO GType++type instance ParentTypes FlowBoxAccessible = FlowBoxAccessibleParentTypes+type FlowBoxAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject FlowBoxAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_flow_box_accessible_get_type+    ++class GObject o => FlowBoxAccessibleK o+instance (GObject o, IsDescendantOf FlowBoxAccessible o) => FlowBoxAccessibleK o++toFlowBoxAccessible :: FlowBoxAccessibleK o => o -> IO FlowBoxAccessible+toFlowBoxAccessible = unsafeCastTo FlowBoxAccessible++noFlowBoxAccessible :: Maybe FlowBoxAccessible+noFlowBoxAccessible = Nothing++type instance AttributeList FlowBoxAccessible = FlowBoxAccessibleAttributeList+type FlowBoxAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FlowBoxAccessible = FlowBoxAccessibleSignalList+type FlowBoxAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/FlowBoxAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FlowBoxAccessible where++import Prelude ()+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 FlowBoxAccessible = FlowBoxAccessible (ForeignPtr FlowBoxAccessible)+instance GObject FlowBoxAccessible where+class GObject o => FlowBoxAccessibleK o+instance (GObject o, IsDescendantOf FlowBoxAccessible o) => FlowBoxAccessibleK o
+ GI/Gtk/Objects/FlowBoxChild.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.Gtk.Objects.FlowBoxChild+    ( ++-- * Exported types+    FlowBoxChild(..)                        ,+    FlowBoxChildK                           ,+    toFlowBoxChild                          ,+    noFlowBoxChild                          ,+++ -- * Methods+-- ** flowBoxChildChanged+    flowBoxChildChanged                     ,+++-- ** flowBoxChildGetIndex+    flowBoxChildGetIndex                    ,+++-- ** flowBoxChildIsSelected+    flowBoxChildIsSelected                  ,+++-- ** flowBoxChildNew+    flowBoxChildNew                         ,+++++ -- * Signals+-- ** Activate+    FlowBoxChildActivateCallback            ,+    FlowBoxChildActivateCallbackC           ,+    FlowBoxChildActivateSignalInfo          ,+    afterFlowBoxChildActivate               ,+    flowBoxChildActivateCallbackWrapper     ,+    flowBoxChildActivateClosure             ,+    mkFlowBoxChildActivateCallback          ,+    noFlowBoxChildActivateCallback          ,+    onFlowBoxChildActivate                  ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FlowBoxChild = FlowBoxChild (ForeignPtr FlowBoxChild)+foreign import ccall "gtk_flow_box_child_get_type"+    c_gtk_flow_box_child_get_type :: IO GType++type instance ParentTypes FlowBoxChild = FlowBoxChildParentTypes+type FlowBoxChildParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject FlowBoxChild where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_flow_box_child_get_type+    ++class GObject o => FlowBoxChildK o+instance (GObject o, IsDescendantOf FlowBoxChild o) => FlowBoxChildK o++toFlowBoxChild :: FlowBoxChildK o => o -> IO FlowBoxChild+toFlowBoxChild = unsafeCastTo FlowBoxChild++noFlowBoxChild :: Maybe FlowBoxChild+noFlowBoxChild = Nothing++-- signal FlowBoxChild::activate+type FlowBoxChildActivateCallback =+    IO ()++noFlowBoxChildActivateCallback :: Maybe FlowBoxChildActivateCallback+noFlowBoxChildActivateCallback = Nothing++type FlowBoxChildActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFlowBoxChildActivateCallback :: FlowBoxChildActivateCallbackC -> IO (FunPtr FlowBoxChildActivateCallbackC)++flowBoxChildActivateClosure :: FlowBoxChildActivateCallback -> IO Closure+flowBoxChildActivateClosure cb = newCClosure =<< mkFlowBoxChildActivateCallback wrapped+    where wrapped = flowBoxChildActivateCallbackWrapper cb++flowBoxChildActivateCallbackWrapper ::+    FlowBoxChildActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+flowBoxChildActivateCallbackWrapper _cb _ _ = do+    _cb ++onFlowBoxChildActivate :: (GObject a, MonadIO m) => a -> FlowBoxChildActivateCallback -> m SignalHandlerId+onFlowBoxChildActivate obj cb = liftIO $ connectFlowBoxChildActivate obj cb SignalConnectBefore+afterFlowBoxChildActivate :: (GObject a, MonadIO m) => a -> FlowBoxChildActivateCallback -> m SignalHandlerId+afterFlowBoxChildActivate obj cb = connectFlowBoxChildActivate obj cb SignalConnectAfter++connectFlowBoxChildActivate :: (GObject a, MonadIO m) =>+                               a -> FlowBoxChildActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectFlowBoxChildActivate obj cb after = liftIO $ do+    cb' <- mkFlowBoxChildActivateCallback (flowBoxChildActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++type instance AttributeList FlowBoxChild = FlowBoxChildAttributeList+type FlowBoxChildAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data FlowBoxChildActivateSignalInfo+instance SignalInfo FlowBoxChildActivateSignalInfo where+    type HaskellCallbackType FlowBoxChildActivateSignalInfo = FlowBoxChildActivateCallback+    connectSignal _ = connectFlowBoxChildActivate++type instance SignalList FlowBoxChild = FlowBoxChildSignalList+type FlowBoxChildSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", FlowBoxChildActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FlowBoxChild::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FlowBoxChild"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_child_new" gtk_flow_box_child_new :: +    IO (Ptr FlowBoxChild)+++flowBoxChildNew ::+    (MonadIO m) =>+    m FlowBoxChild+flowBoxChildNew  = liftIO $ do+    result <- gtk_flow_box_child_new+    checkUnexpectedReturnNULL "gtk_flow_box_child_new" result+    result' <- (newObject FlowBoxChild) result+    return result'++-- method FlowBoxChild::changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_child_changed" gtk_flow_box_child_changed :: +    Ptr FlowBoxChild ->                     -- _obj : TInterface "Gtk" "FlowBoxChild"+    IO ()+++flowBoxChildChanged ::+    (MonadIO m, FlowBoxChildK a) =>+    a ->                                    -- _obj+    m ()+flowBoxChildChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_flow_box_child_changed _obj'+    touchManagedPtr _obj+    return ()++-- method FlowBoxChild::get_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_child_get_index" gtk_flow_box_child_get_index :: +    Ptr FlowBoxChild ->                     -- _obj : TInterface "Gtk" "FlowBoxChild"+    IO Int32+++flowBoxChildGetIndex ::+    (MonadIO m, FlowBoxChildK a) =>+    a ->                                    -- _obj+    m Int32+flowBoxChildGetIndex _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_child_get_index _obj'+    touchManagedPtr _obj+    return result++-- method FlowBoxChild::is_selected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FlowBoxChild", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_flow_box_child_is_selected" gtk_flow_box_child_is_selected :: +    Ptr FlowBoxChild ->                     -- _obj : TInterface "Gtk" "FlowBoxChild"+    IO CInt+++flowBoxChildIsSelected ::+    (MonadIO m, FlowBoxChildK a) =>+    a ->                                    -- _obj+    m Bool+flowBoxChildIsSelected _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_flow_box_child_is_selected _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/FlowBoxChild.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.FlowBoxChild where++import Prelude ()+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 FlowBoxChild = FlowBoxChild (ForeignPtr FlowBoxChild)+instance GObject FlowBoxChild where+class GObject o => FlowBoxChildK o+instance (GObject o, IsDescendantOf FlowBoxChild o) => FlowBoxChildK o+data FlowBoxChildActivateSignalInfo
+ GI/Gtk/Objects/FlowBoxChildAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.FlowBoxChildAccessible+    ( ++-- * Exported types+    FlowBoxChildAccessible(..)              ,+    FlowBoxChildAccessibleK                 ,+    toFlowBoxChildAccessible                ,+    noFlowBoxChildAccessible                ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FlowBoxChildAccessible = FlowBoxChildAccessible (ForeignPtr FlowBoxChildAccessible)+foreign import ccall "gtk_flow_box_child_accessible_get_type"+    c_gtk_flow_box_child_accessible_get_type :: IO GType++type instance ParentTypes FlowBoxChildAccessible = FlowBoxChildAccessibleParentTypes+type FlowBoxChildAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component]++instance GObject FlowBoxChildAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_flow_box_child_accessible_get_type+    ++class GObject o => FlowBoxChildAccessibleK o+instance (GObject o, IsDescendantOf FlowBoxChildAccessible o) => FlowBoxChildAccessibleK o++toFlowBoxChildAccessible :: FlowBoxChildAccessibleK o => o -> IO FlowBoxChildAccessible+toFlowBoxChildAccessible = unsafeCastTo FlowBoxChildAccessible++noFlowBoxChildAccessible :: Maybe FlowBoxChildAccessible+noFlowBoxChildAccessible = Nothing++type instance AttributeList FlowBoxChildAccessible = FlowBoxChildAccessibleAttributeList+type FlowBoxChildAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FlowBoxChildAccessible = FlowBoxChildAccessibleSignalList+type FlowBoxChildAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/FlowBoxChildAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FlowBoxChildAccessible where++import Prelude ()+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 FlowBoxChildAccessible = FlowBoxChildAccessible (ForeignPtr FlowBoxChildAccessible)+instance GObject FlowBoxChildAccessible where+class GObject o => FlowBoxChildAccessibleK o+instance (GObject o, IsDescendantOf FlowBoxChildAccessible o) => FlowBoxChildAccessibleK o
+ GI/Gtk/Objects/FontButton.hs view
@@ -0,0 +1,730 @@++{- |+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.Gtk.Objects.FontButton+    ( ++-- * Exported types+    FontButton(..)                          ,+    FontButtonK                             ,+    toFontButton                            ,+    noFontButton                            ,+++ -- * Methods+-- ** fontButtonGetFontName+    fontButtonGetFontName                   ,+++-- ** fontButtonGetShowSize+    fontButtonGetShowSize                   ,+++-- ** fontButtonGetShowStyle+    fontButtonGetShowStyle                  ,+++-- ** fontButtonGetTitle+    fontButtonGetTitle                      ,+++-- ** fontButtonGetUseFont+    fontButtonGetUseFont                    ,+++-- ** fontButtonGetUseSize+    fontButtonGetUseSize                    ,+++-- ** fontButtonNew+    fontButtonNew                           ,+++-- ** fontButtonNewWithFont+    fontButtonNewWithFont                   ,+++-- ** fontButtonSetFontName+    fontButtonSetFontName                   ,+++-- ** fontButtonSetShowSize+    fontButtonSetShowSize                   ,+++-- ** fontButtonSetShowStyle+    fontButtonSetShowStyle                  ,+++-- ** fontButtonSetTitle+    fontButtonSetTitle                      ,+++-- ** fontButtonSetUseFont+    fontButtonSetUseFont                    ,+++-- ** fontButtonSetUseSize+    fontButtonSetUseSize                    ,+++++ -- * Properties+-- ** FontName+    FontButtonFontNamePropertyInfo          ,+    constructFontButtonFontName             ,+    getFontButtonFontName                   ,+    setFontButtonFontName                   ,+++-- ** ShowSize+    FontButtonShowSizePropertyInfo          ,+    constructFontButtonShowSize             ,+    getFontButtonShowSize                   ,+    setFontButtonShowSize                   ,+++-- ** ShowStyle+    FontButtonShowStylePropertyInfo         ,+    constructFontButtonShowStyle            ,+    getFontButtonShowStyle                  ,+    setFontButtonShowStyle                  ,+++-- ** Title+    FontButtonTitlePropertyInfo             ,+    constructFontButtonTitle                ,+    getFontButtonTitle                      ,+    setFontButtonTitle                      ,+++-- ** UseFont+    FontButtonUseFontPropertyInfo           ,+    constructFontButtonUseFont              ,+    getFontButtonUseFont                    ,+    setFontButtonUseFont                    ,+++-- ** UseSize+    FontButtonUseSizePropertyInfo           ,+    constructFontButtonUseSize              ,+    getFontButtonUseSize                    ,+    setFontButtonUseSize                    ,+++++ -- * Signals+-- ** FontSet+    FontButtonFontSetCallback               ,+    FontButtonFontSetCallbackC              ,+    FontButtonFontSetSignalInfo             ,+    afterFontButtonFontSet                  ,+    fontButtonFontSetCallbackWrapper        ,+    fontButtonFontSetClosure                ,+    mkFontButtonFontSetCallback             ,+    noFontButtonFontSetCallback             ,+    onFontButtonFontSet                     ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FontButton = FontButton (ForeignPtr FontButton)+foreign import ccall "gtk_font_button_get_type"+    c_gtk_font_button_get_type :: IO GType++type instance ParentTypes FontButton = FontButtonParentTypes+type FontButtonParentTypes = '[Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable, FontChooser]++instance GObject FontButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_font_button_get_type+    ++class GObject o => FontButtonK o+instance (GObject o, IsDescendantOf FontButton o) => FontButtonK o++toFontButton :: FontButtonK o => o -> IO FontButton+toFontButton = unsafeCastTo FontButton++noFontButton :: Maybe FontButton+noFontButton = Nothing++-- signal FontButton::font-set+type FontButtonFontSetCallback =+    IO ()++noFontButtonFontSetCallback :: Maybe FontButtonFontSetCallback+noFontButtonFontSetCallback = Nothing++type FontButtonFontSetCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkFontButtonFontSetCallback :: FontButtonFontSetCallbackC -> IO (FunPtr FontButtonFontSetCallbackC)++fontButtonFontSetClosure :: FontButtonFontSetCallback -> IO Closure+fontButtonFontSetClosure cb = newCClosure =<< mkFontButtonFontSetCallback wrapped+    where wrapped = fontButtonFontSetCallbackWrapper cb++fontButtonFontSetCallbackWrapper ::+    FontButtonFontSetCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+fontButtonFontSetCallbackWrapper _cb _ _ = do+    _cb ++onFontButtonFontSet :: (GObject a, MonadIO m) => a -> FontButtonFontSetCallback -> m SignalHandlerId+onFontButtonFontSet obj cb = liftIO $ connectFontButtonFontSet obj cb SignalConnectBefore+afterFontButtonFontSet :: (GObject a, MonadIO m) => a -> FontButtonFontSetCallback -> m SignalHandlerId+afterFontButtonFontSet obj cb = connectFontButtonFontSet obj cb SignalConnectAfter++connectFontButtonFontSet :: (GObject a, MonadIO m) =>+                            a -> FontButtonFontSetCallback -> SignalConnectMode -> m SignalHandlerId+connectFontButtonFontSet obj cb after = liftIO $ do+    cb' <- mkFontButtonFontSetCallback (fontButtonFontSetCallbackWrapper cb)+    connectSignalFunPtr obj "font-set" cb' after++-- VVV Prop "font-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonFontName :: (MonadIO m, FontButtonK o) => o -> m T.Text+getFontButtonFontName obj = liftIO $ getObjectPropertyString obj "font-name"++setFontButtonFontName :: (MonadIO m, FontButtonK o) => o -> T.Text -> m ()+setFontButtonFontName obj val = liftIO $ setObjectPropertyString obj "font-name" val++constructFontButtonFontName :: T.Text -> IO ([Char], GValue)+constructFontButtonFontName val = constructObjectPropertyString "font-name" val++data FontButtonFontNamePropertyInfo+instance AttrInfo FontButtonFontNamePropertyInfo where+    type AttrAllowedOps FontButtonFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonFontNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontButtonFontNamePropertyInfo = FontButtonK+    type AttrGetType FontButtonFontNamePropertyInfo = T.Text+    type AttrLabel FontButtonFontNamePropertyInfo = "FontButton::font-name"+    attrGet _ = getFontButtonFontName+    attrSet _ = setFontButtonFontName+    attrConstruct _ = constructFontButtonFontName++-- VVV Prop "show-size"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonShowSize :: (MonadIO m, FontButtonK o) => o -> m Bool+getFontButtonShowSize obj = liftIO $ getObjectPropertyBool obj "show-size"++setFontButtonShowSize :: (MonadIO m, FontButtonK o) => o -> Bool -> m ()+setFontButtonShowSize obj val = liftIO $ setObjectPropertyBool obj "show-size" val++constructFontButtonShowSize :: Bool -> IO ([Char], GValue)+constructFontButtonShowSize val = constructObjectPropertyBool "show-size" val++data FontButtonShowSizePropertyInfo+instance AttrInfo FontButtonShowSizePropertyInfo where+    type AttrAllowedOps FontButtonShowSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonShowSizePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FontButtonShowSizePropertyInfo = FontButtonK+    type AttrGetType FontButtonShowSizePropertyInfo = Bool+    type AttrLabel FontButtonShowSizePropertyInfo = "FontButton::show-size"+    attrGet _ = getFontButtonShowSize+    attrSet _ = setFontButtonShowSize+    attrConstruct _ = constructFontButtonShowSize++-- VVV Prop "show-style"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonShowStyle :: (MonadIO m, FontButtonK o) => o -> m Bool+getFontButtonShowStyle obj = liftIO $ getObjectPropertyBool obj "show-style"++setFontButtonShowStyle :: (MonadIO m, FontButtonK o) => o -> Bool -> m ()+setFontButtonShowStyle obj val = liftIO $ setObjectPropertyBool obj "show-style" val++constructFontButtonShowStyle :: Bool -> IO ([Char], GValue)+constructFontButtonShowStyle val = constructObjectPropertyBool "show-style" val++data FontButtonShowStylePropertyInfo+instance AttrInfo FontButtonShowStylePropertyInfo where+    type AttrAllowedOps FontButtonShowStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonShowStylePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FontButtonShowStylePropertyInfo = FontButtonK+    type AttrGetType FontButtonShowStylePropertyInfo = Bool+    type AttrLabel FontButtonShowStylePropertyInfo = "FontButton::show-style"+    attrGet _ = getFontButtonShowStyle+    attrSet _ = setFontButtonShowStyle+    attrConstruct _ = constructFontButtonShowStyle++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonTitle :: (MonadIO m, FontButtonK o) => o -> m T.Text+getFontButtonTitle obj = liftIO $ getObjectPropertyString obj "title"++setFontButtonTitle :: (MonadIO m, FontButtonK o) => o -> T.Text -> m ()+setFontButtonTitle obj val = liftIO $ setObjectPropertyString obj "title" val++constructFontButtonTitle :: T.Text -> IO ([Char], GValue)+constructFontButtonTitle val = constructObjectPropertyString "title" val++data FontButtonTitlePropertyInfo+instance AttrInfo FontButtonTitlePropertyInfo where+    type AttrAllowedOps FontButtonTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontButtonTitlePropertyInfo = FontButtonK+    type AttrGetType FontButtonTitlePropertyInfo = T.Text+    type AttrLabel FontButtonTitlePropertyInfo = "FontButton::title"+    attrGet _ = getFontButtonTitle+    attrSet _ = setFontButtonTitle+    attrConstruct _ = constructFontButtonTitle++-- VVV Prop "use-font"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonUseFont :: (MonadIO m, FontButtonK o) => o -> m Bool+getFontButtonUseFont obj = liftIO $ getObjectPropertyBool obj "use-font"++setFontButtonUseFont :: (MonadIO m, FontButtonK o) => o -> Bool -> m ()+setFontButtonUseFont obj val = liftIO $ setObjectPropertyBool obj "use-font" val++constructFontButtonUseFont :: Bool -> IO ([Char], GValue)+constructFontButtonUseFont val = constructObjectPropertyBool "use-font" val++data FontButtonUseFontPropertyInfo+instance AttrInfo FontButtonUseFontPropertyInfo where+    type AttrAllowedOps FontButtonUseFontPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonUseFontPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FontButtonUseFontPropertyInfo = FontButtonK+    type AttrGetType FontButtonUseFontPropertyInfo = Bool+    type AttrLabel FontButtonUseFontPropertyInfo = "FontButton::use-font"+    attrGet _ = getFontButtonUseFont+    attrSet _ = setFontButtonUseFont+    attrConstruct _ = constructFontButtonUseFont++-- VVV Prop "use-size"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getFontButtonUseSize :: (MonadIO m, FontButtonK o) => o -> m Bool+getFontButtonUseSize obj = liftIO $ getObjectPropertyBool obj "use-size"++setFontButtonUseSize :: (MonadIO m, FontButtonK o) => o -> Bool -> m ()+setFontButtonUseSize obj val = liftIO $ setObjectPropertyBool obj "use-size" val++constructFontButtonUseSize :: Bool -> IO ([Char], GValue)+constructFontButtonUseSize val = constructObjectPropertyBool "use-size" val++data FontButtonUseSizePropertyInfo+instance AttrInfo FontButtonUseSizePropertyInfo where+    type AttrAllowedOps FontButtonUseSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontButtonUseSizePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint FontButtonUseSizePropertyInfo = FontButtonK+    type AttrGetType FontButtonUseSizePropertyInfo = Bool+    type AttrLabel FontButtonUseSizePropertyInfo = "FontButton::use-size"+    attrGet _ = getFontButtonUseSize+    attrSet _ = setFontButtonUseSize+    attrConstruct _ = constructFontButtonUseSize++type instance AttributeList FontButton = FontButtonAttributeList+type FontButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("font", FontChooserFontPropertyInfo), '("font-desc", FontChooserFontDescPropertyInfo), '("font-name", FontButtonFontNamePropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-text", FontChooserPreviewTextPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-preview-entry", FontChooserShowPreviewEntryPropertyInfo), '("show-size", FontButtonShowSizePropertyInfo), '("show-style", FontButtonShowStylePropertyInfo), '("style", WidgetStylePropertyInfo), '("title", FontButtonTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-font", FontButtonUseFontPropertyInfo), '("use-size", FontButtonUseSizePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++data FontButtonFontSetSignalInfo+instance SignalInfo FontButtonFontSetSignalInfo where+    type HaskellCallbackType FontButtonFontSetSignalInfo = FontButtonFontSetCallback+    connectSignal _ = connectFontButtonFontSet++type instance SignalList FontButton = FontButtonSignalList+type FontButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("font-activated", FontChooserFontActivatedSignalInfo), '("font-set", FontButtonFontSetSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontButton::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FontButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_new" gtk_font_button_new :: +    IO (Ptr FontButton)+++fontButtonNew ::+    (MonadIO m) =>+    m FontButton+fontButtonNew  = liftIO $ do+    result <- gtk_font_button_new+    checkUnexpectedReturnNULL "gtk_font_button_new" result+    result' <- (newObject FontButton) result+    return result'++-- method FontButton::new_with_font+-- method type : Constructor+-- Args : [Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FontButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_new_with_font" gtk_font_button_new_with_font :: +    CString ->                              -- fontname : TBasicType TUTF8+    IO (Ptr FontButton)+++fontButtonNewWithFont ::+    (MonadIO m) =>+    T.Text ->                               -- fontname+    m FontButton+fontButtonNewWithFont fontname = liftIO $ do+    fontname' <- textToCString fontname+    result <- gtk_font_button_new_with_font fontname'+    checkUnexpectedReturnNULL "gtk_font_button_new_with_font" result+    result' <- (newObject FontButton) result+    freeMem fontname'+    return result'++-- method FontButton::get_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_font_name" gtk_font_button_get_font_name :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CString+++fontButtonGetFontName ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m T.Text+fontButtonGetFontName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_font_name _obj'+    checkUnexpectedReturnNULL "gtk_font_button_get_font_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontButton::get_show_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_show_size" gtk_font_button_get_show_size :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CInt+++fontButtonGetShowSize ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m Bool+fontButtonGetShowSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_show_size _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontButton::get_show_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_show_style" gtk_font_button_get_show_style :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CInt+++fontButtonGetShowStyle ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m Bool+fontButtonGetShowStyle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_show_style _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontButton::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_title" gtk_font_button_get_title :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CString+++fontButtonGetTitle ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m T.Text+fontButtonGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_title _obj'+    checkUnexpectedReturnNULL "gtk_font_button_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontButton::get_use_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_use_font" gtk_font_button_get_use_font :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CInt+++fontButtonGetUseFont ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m Bool+fontButtonGetUseFont _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_use_font _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontButton::get_use_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_button_get_use_size" gtk_font_button_get_use_size :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    IO CInt+++fontButtonGetUseSize ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    m Bool+fontButtonGetUseSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_button_get_use_size _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontButton::set_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", 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 "gtk_font_button_set_font_name" gtk_font_button_set_font_name :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CString ->                              -- fontname : TBasicType TUTF8+    IO CInt+++fontButtonSetFontName ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- fontname+    m Bool+fontButtonSetFontName _obj fontname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    fontname' <- textToCString fontname+    result <- gtk_font_button_set_font_name _obj' fontname'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fontname'+    return result'++-- method FontButton::set_show_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_size", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_size", 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 "gtk_font_button_set_show_size" gtk_font_button_set_show_size :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CInt ->                                 -- show_size : TBasicType TBoolean+    IO ()+++fontButtonSetShowSize ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_size+    m ()+fontButtonSetShowSize _obj show_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_size' = (fromIntegral . fromEnum) show_size+    gtk_font_button_set_show_size _obj' show_size'+    touchManagedPtr _obj+    return ()++-- method FontButton::set_show_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_style", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_style", 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 "gtk_font_button_set_show_style" gtk_font_button_set_show_style :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CInt ->                                 -- show_style : TBasicType TBoolean+    IO ()+++fontButtonSetShowStyle ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_style+    m ()+fontButtonSetShowStyle _obj show_style = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_style' = (fromIntegral . fromEnum) show_style+    gtk_font_button_set_show_style _obj' show_style'+    touchManagedPtr _obj+    return ()++-- method FontButton::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", 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 "Gtk" "FontButton", 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 "gtk_font_button_set_title" gtk_font_button_set_title :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++fontButtonSetTitle ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+fontButtonSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    gtk_font_button_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method FontButton::set_use_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_font", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_font", 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 "gtk_font_button_set_use_font" gtk_font_button_set_use_font :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CInt ->                                 -- use_font : TBasicType TBoolean+    IO ()+++fontButtonSetUseFont ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_font+    m ()+fontButtonSetUseFont _obj use_font = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_font' = (fromIntegral . fromEnum) use_font+    gtk_font_button_set_use_font _obj' use_font'+    touchManagedPtr _obj+    return ()++-- method FontButton::set_use_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_size", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_size", 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 "gtk_font_button_set_use_size" gtk_font_button_set_use_size :: +    Ptr FontButton ->                       -- _obj : TInterface "Gtk" "FontButton"+    CInt ->                                 -- use_size : TBasicType TBoolean+    IO ()+++fontButtonSetUseSize ::+    (MonadIO m, FontButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_size+    m ()+fontButtonSetUseSize _obj use_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_size' = (fromIntegral . fromEnum) use_size+    gtk_font_button_set_use_size _obj' use_size'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/FontButton.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gtk.Objects.FontButton where++import Prelude ()+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 FontButton = FontButton (ForeignPtr FontButton)+instance GObject FontButton where+class GObject o => FontButtonK o+instance (GObject o, IsDescendantOf FontButton o) => FontButtonK o+data FontButtonFontNamePropertyInfo+data FontButtonShowSizePropertyInfo+data FontButtonShowStylePropertyInfo+data FontButtonTitlePropertyInfo+data FontButtonUseFontPropertyInfo+data FontButtonUseSizePropertyInfo+data FontButtonFontSetSignalInfo
+ GI/Gtk/Objects/FontChooserDialog.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.Gtk.Objects.FontChooserDialog+    ( ++-- * Exported types+    FontChooserDialog(..)                   ,+    FontChooserDialogK                      ,+    toFontChooserDialog                     ,+    noFontChooserDialog                     ,+++ -- * Methods+-- ** fontChooserDialogNew+    fontChooserDialogNew                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FontChooserDialog = FontChooserDialog (ForeignPtr FontChooserDialog)+foreign import ccall "gtk_font_chooser_dialog_get_type"+    c_gtk_font_chooser_dialog_get_type :: IO GType++type instance ParentTypes FontChooserDialog = FontChooserDialogParentTypes+type FontChooserDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, FontChooser]++instance GObject FontChooserDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_font_chooser_dialog_get_type+    ++class GObject o => FontChooserDialogK o+instance (GObject o, IsDescendantOf FontChooserDialog o) => FontChooserDialogK o++toFontChooserDialog :: FontChooserDialogK o => o -> IO FontChooserDialog+toFontChooserDialog = unsafeCastTo FontChooserDialog++noFontChooserDialog :: Maybe FontChooserDialog+noFontChooserDialog = Nothing++type instance AttributeList FontChooserDialog = FontChooserDialogAttributeList+type FontChooserDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("font", FontChooserFontPropertyInfo), '("font-desc", FontChooserFontDescPropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-text", FontChooserPreviewTextPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-preview-entry", FontChooserShowPreviewEntryPropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FontChooserDialog = FontChooserDialogSignalList+type FontChooserDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("font-activated", FontChooserFontActivatedSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontChooserDialog::new+-- method type : Constructor+-- Args : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "FontChooserDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_dialog_new" gtk_font_chooser_dialog_new :: +    CString ->                              -- title : TBasicType TUTF8+    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    IO (Ptr FontChooserDialog)+++fontChooserDialogNew ::+    (MonadIO m, WindowK a) =>+    Maybe (T.Text) ->                       -- title+    Maybe (a) ->                            -- parent+    m FontChooserDialog+fontChooserDialogNew title parent = liftIO $ do+    maybeTitle <- case title of+        Nothing -> return nullPtr+        Just jTitle -> do+            jTitle' <- textToCString jTitle+            return jTitle'+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- gtk_font_chooser_dialog_new maybeTitle maybeParent+    checkUnexpectedReturnNULL "gtk_font_chooser_dialog_new" result+    result' <- (newObject FontChooserDialog) result+    whenJust parent touchManagedPtr+    freeMem maybeTitle+    return result'++
+ GI/Gtk/Objects/FontChooserDialog.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FontChooserDialog where++import Prelude ()+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 FontChooserDialog = FontChooserDialog (ForeignPtr FontChooserDialog)+instance GObject FontChooserDialog where+class GObject o => FontChooserDialogK o+instance (GObject o, IsDescendantOf FontChooserDialog o) => FontChooserDialogK o
+ GI/Gtk/Objects/FontChooserWidget.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.Gtk.Objects.FontChooserWidget+    ( ++-- * Exported types+    FontChooserWidget(..)                   ,+    FontChooserWidgetK                      ,+    toFontChooserWidget                     ,+    noFontChooserWidget                     ,+++ -- * Methods+-- ** fontChooserWidgetNew+    fontChooserWidgetNew                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FontChooserWidget = FontChooserWidget (ForeignPtr FontChooserWidget)+foreign import ccall "gtk_font_chooser_widget_get_type"+    c_gtk_font_chooser_widget_get_type :: IO GType++type instance ParentTypes FontChooserWidget = FontChooserWidgetParentTypes+type FontChooserWidgetParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, FontChooser, Orientable]++instance GObject FontChooserWidget where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_font_chooser_widget_get_type+    ++class GObject o => FontChooserWidgetK o+instance (GObject o, IsDescendantOf FontChooserWidget o) => FontChooserWidgetK o++toFontChooserWidget :: FontChooserWidgetK o => o -> IO FontChooserWidget+toFontChooserWidget = unsafeCastTo FontChooserWidget++noFontChooserWidget :: Maybe FontChooserWidget+noFontChooserWidget = Nothing++type instance AttributeList FontChooserWidget = FontChooserWidgetAttributeList+type FontChooserWidgetAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("font", FontChooserFontPropertyInfo), '("font-desc", FontChooserFontDescPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-text", FontChooserPreviewTextPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-preview-entry", FontChooserShowPreviewEntryPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FontChooserWidget = FontChooserWidgetSignalList+type FontChooserWidgetSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("font-activated", FontChooserFontActivatedSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontChooserWidget::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FontChooserWidget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_chooser_widget_new" gtk_font_chooser_widget_new :: +    IO (Ptr FontChooserWidget)+++fontChooserWidgetNew ::+    (MonadIO m) =>+    m FontChooserWidget+fontChooserWidgetNew  = liftIO $ do+    result <- gtk_font_chooser_widget_new+    checkUnexpectedReturnNULL "gtk_font_chooser_widget_new" result+    result' <- (newObject FontChooserWidget) result+    return result'++
+ GI/Gtk/Objects/FontChooserWidget.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FontChooserWidget where++import Prelude ()+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 FontChooserWidget = FontChooserWidget (ForeignPtr FontChooserWidget)+instance GObject FontChooserWidget where+class GObject o => FontChooserWidgetK o+instance (GObject o, IsDescendantOf FontChooserWidget o) => FontChooserWidgetK o
+ GI/Gtk/Objects/FontSelection.hs view
@@ -0,0 +1,518 @@++{- |+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.Gtk.Objects.FontSelection+    ( ++-- * Exported types+    FontSelection(..)                       ,+    FontSelectionK                          ,+    toFontSelection                         ,+    noFontSelection                         ,+++ -- * Methods+-- ** fontSelectionGetFace+    fontSelectionGetFace                    ,+++-- ** fontSelectionGetFaceList+    fontSelectionGetFaceList                ,+++-- ** fontSelectionGetFamily+    fontSelectionGetFamily                  ,+++-- ** fontSelectionGetFamilyList+    fontSelectionGetFamilyList              ,+++-- ** fontSelectionGetFontName+    fontSelectionGetFontName                ,+++-- ** fontSelectionGetPreviewEntry+    fontSelectionGetPreviewEntry            ,+++-- ** fontSelectionGetPreviewText+    fontSelectionGetPreviewText             ,+++-- ** fontSelectionGetSize+    fontSelectionGetSize                    ,+++-- ** fontSelectionGetSizeEntry+    fontSelectionGetSizeEntry               ,+++-- ** fontSelectionGetSizeList+    fontSelectionGetSizeList                ,+++-- ** fontSelectionNew+    fontSelectionNew                        ,+++-- ** fontSelectionSetFontName+    fontSelectionSetFontName                ,+++-- ** fontSelectionSetPreviewText+    fontSelectionSetPreviewText             ,+++++ -- * Properties+-- ** FontName+    FontSelectionFontNamePropertyInfo       ,+    constructFontSelectionFontName          ,+    getFontSelectionFontName                ,+    setFontSelectionFontName                ,+++-- ** PreviewText+    FontSelectionPreviewTextPropertyInfo    ,+    constructFontSelectionPreviewText       ,+    getFontSelectionPreviewText             ,+    setFontSelectionPreviewText             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango++newtype FontSelection = FontSelection (ForeignPtr FontSelection)+foreign import ccall "gtk_font_selection_get_type"+    c_gtk_font_selection_get_type :: IO GType++type instance ParentTypes FontSelection = FontSelectionParentTypes+type FontSelectionParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject FontSelection where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_font_selection_get_type+    ++class GObject o => FontSelectionK o+instance (GObject o, IsDescendantOf FontSelection o) => FontSelectionK o++toFontSelection :: FontSelectionK o => o -> IO FontSelection+toFontSelection = unsafeCastTo FontSelection++noFontSelection :: Maybe FontSelection+noFontSelection = Nothing++-- VVV Prop "font-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontSelectionFontName :: (MonadIO m, FontSelectionK o) => o -> m T.Text+getFontSelectionFontName obj = liftIO $ getObjectPropertyString obj "font-name"++setFontSelectionFontName :: (MonadIO m, FontSelectionK o) => o -> T.Text -> m ()+setFontSelectionFontName obj val = liftIO $ setObjectPropertyString obj "font-name" val++constructFontSelectionFontName :: T.Text -> IO ([Char], GValue)+constructFontSelectionFontName val = constructObjectPropertyString "font-name" val++data FontSelectionFontNamePropertyInfo+instance AttrInfo FontSelectionFontNamePropertyInfo where+    type AttrAllowedOps FontSelectionFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontSelectionFontNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontSelectionFontNamePropertyInfo = FontSelectionK+    type AttrGetType FontSelectionFontNamePropertyInfo = T.Text+    type AttrLabel FontSelectionFontNamePropertyInfo = "FontSelection::font-name"+    attrGet _ = getFontSelectionFontName+    attrSet _ = setFontSelectionFontName+    attrConstruct _ = constructFontSelectionFontName++-- VVV Prop "preview-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFontSelectionPreviewText :: (MonadIO m, FontSelectionK o) => o -> m T.Text+getFontSelectionPreviewText obj = liftIO $ getObjectPropertyString obj "preview-text"++setFontSelectionPreviewText :: (MonadIO m, FontSelectionK o) => o -> T.Text -> m ()+setFontSelectionPreviewText obj val = liftIO $ setObjectPropertyString obj "preview-text" val++constructFontSelectionPreviewText :: T.Text -> IO ([Char], GValue)+constructFontSelectionPreviewText val = constructObjectPropertyString "preview-text" val++data FontSelectionPreviewTextPropertyInfo+instance AttrInfo FontSelectionPreviewTextPropertyInfo where+    type AttrAllowedOps FontSelectionPreviewTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FontSelectionPreviewTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FontSelectionPreviewTextPropertyInfo = FontSelectionK+    type AttrGetType FontSelectionPreviewTextPropertyInfo = T.Text+    type AttrLabel FontSelectionPreviewTextPropertyInfo = "FontSelection::preview-text"+    attrGet _ = getFontSelectionPreviewText+    attrSet _ = setFontSelectionPreviewText+    attrConstruct _ = constructFontSelectionPreviewText++type instance AttributeList FontSelection = FontSelectionAttributeList+type FontSelectionAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("font-name", FontSelectionFontNamePropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("preview-text", FontSelectionPreviewTextPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FontSelection = FontSelectionSignalList+type FontSelectionSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontSelection::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "FontSelection"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_new" gtk_font_selection_new :: +    IO (Ptr FontSelection)++{-# DEPRECATED fontSelectionNew ["(Since version 3.2)","Use #GtkFontChooserWidget instead"]#-}+fontSelectionNew ::+    (MonadIO m) =>+    m FontSelection+fontSelectionNew  = liftIO $ do+    result <- gtk_font_selection_new+    checkUnexpectedReturnNULL "gtk_font_selection_new" result+    result' <- (newObject FontSelection) result+    return result'++-- method FontSelection::get_face+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontFace"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_face" gtk_font_selection_get_face :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Pango.FontFace)++{-# DEPRECATED fontSelectionGetFace ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetFace ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Pango.FontFace+fontSelectionGetFace _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_face _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_face" result+    result' <- (newObject Pango.FontFace) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_face_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_face_list" gtk_font_selection_get_face_list :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionGetFaceList ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetFaceList ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionGetFaceList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_face_list _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_face_list" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_family+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontFamily"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_family" gtk_font_selection_get_family :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Pango.FontFamily)++{-# DEPRECATED fontSelectionGetFamily ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetFamily ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Pango.FontFamily+fontSelectionGetFamily _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_family _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_family" result+    result' <- (newObject Pango.FontFamily) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_family_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_family_list" gtk_font_selection_get_family_list :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionGetFamilyList ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetFamilyList ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionGetFamilyList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_family_list _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_family_list" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_font_name" gtk_font_selection_get_font_name :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO CString++{-# DEPRECATED fontSelectionGetFontName ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetFontName ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m T.Text+fontSelectionGetFontName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_font_name _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_font_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_preview_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_preview_entry" gtk_font_selection_get_preview_entry :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionGetPreviewEntry ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetPreviewEntry ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionGetPreviewEntry _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_preview_entry _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_preview_entry" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_preview_text" gtk_font_selection_get_preview_text :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO CString++{-# DEPRECATED fontSelectionGetPreviewText ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetPreviewText ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m T.Text+fontSelectionGetPreviewText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_preview_text _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_preview_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_size" gtk_font_selection_get_size :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO Int32++{-# DEPRECATED fontSelectionGetSize ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetSize ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Int32+fontSelectionGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_size _obj'+    touchManagedPtr _obj+    return result++-- method FontSelection::get_size_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_size_entry" gtk_font_selection_get_size_entry :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionGetSizeEntry ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetSizeEntry ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionGetSizeEntry _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_size_entry _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_size_entry" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::get_size_list+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_get_size_list" gtk_font_selection_get_size_list :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionGetSizeList ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionGetSizeList ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionGetSizeList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_get_size_list _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_get_size_list" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelection::set_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", 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 "gtk_font_selection_set_font_name" gtk_font_selection_set_font_name :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    CString ->                              -- fontname : TBasicType TUTF8+    IO CInt++{-# DEPRECATED fontSelectionSetFontName ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionSetFontName ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- fontname+    m Bool+fontSelectionSetFontName _obj fontname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    fontname' <- textToCString fontname+    result <- gtk_font_selection_set_font_name _obj' fontname'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fontname'+    return result'++-- method FontSelection::set_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_font_selection_set_preview_text" gtk_font_selection_set_preview_text :: +    Ptr FontSelection ->                    -- _obj : TInterface "Gtk" "FontSelection"+    CString ->                              -- text : TBasicType TUTF8+    IO ()++{-# DEPRECATED fontSelectionSetPreviewText ["(Since version 3.2)","Use #GtkFontChooser"]#-}+fontSelectionSetPreviewText ::+    (MonadIO m, FontSelectionK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+fontSelectionSetPreviewText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_font_selection_set_preview_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++
+ GI/Gtk/Objects/FontSelection.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.FontSelection where++import Prelude ()+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 FontSelection = FontSelection (ForeignPtr FontSelection)+instance GObject FontSelection where+class GObject o => FontSelectionK o+instance (GObject o, IsDescendantOf FontSelection o) => FontSelectionK o+data FontSelectionFontNamePropertyInfo+data FontSelectionPreviewTextPropertyInfo
+ GI/Gtk/Objects/FontSelectionDialog.hs view
@@ -0,0 +1,308 @@++{- |+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.Gtk.Objects.FontSelectionDialog+    ( ++-- * Exported types+    FontSelectionDialog(..)                 ,+    FontSelectionDialogK                    ,+    toFontSelectionDialog                   ,+    noFontSelectionDialog                   ,+++ -- * Methods+-- ** fontSelectionDialogGetCancelButton+    fontSelectionDialogGetCancelButton      ,+++-- ** fontSelectionDialogGetFontName+    fontSelectionDialogGetFontName          ,+++-- ** fontSelectionDialogGetFontSelection+    fontSelectionDialogGetFontSelection     ,+++-- ** fontSelectionDialogGetOkButton+    fontSelectionDialogGetOkButton          ,+++-- ** fontSelectionDialogGetPreviewText+    fontSelectionDialogGetPreviewText       ,+++-- ** fontSelectionDialogNew+    fontSelectionDialogNew                  ,+++-- ** fontSelectionDialogSetFontName+    fontSelectionDialogSetFontName          ,+++-- ** fontSelectionDialogSetPreviewText+    fontSelectionDialogSetPreviewText       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FontSelectionDialog = FontSelectionDialog (ForeignPtr FontSelectionDialog)+foreign import ccall "gtk_font_selection_dialog_get_type"+    c_gtk_font_selection_dialog_get_type :: IO GType++type instance ParentTypes FontSelectionDialog = FontSelectionDialogParentTypes+type FontSelectionDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject FontSelectionDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_font_selection_dialog_get_type+    ++class GObject o => FontSelectionDialogK o+instance (GObject o, IsDescendantOf FontSelectionDialog o) => FontSelectionDialogK o++toFontSelectionDialog :: FontSelectionDialogK o => o -> IO FontSelectionDialog+toFontSelectionDialog = unsafeCastTo FontSelectionDialog++noFontSelectionDialog :: Maybe FontSelectionDialog+noFontSelectionDialog = Nothing++type instance AttributeList FontSelectionDialog = FontSelectionDialogAttributeList+type FontSelectionDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FontSelectionDialog = FontSelectionDialogSignalList+type FontSelectionDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontSelectionDialog::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 "Gtk" "FontSelectionDialog"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_new" gtk_font_selection_dialog_new :: +    CString ->                              -- title : TBasicType TUTF8+    IO (Ptr FontSelectionDialog)++{-# DEPRECATED fontSelectionDialogNew ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogNew ::+    (MonadIO m) =>+    T.Text ->                               -- title+    m FontSelectionDialog+fontSelectionDialogNew title = liftIO $ do+    title' <- textToCString title+    result <- gtk_font_selection_dialog_new title'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_new" result+    result' <- (newObject FontSelectionDialog) result+    freeMem title'+    return result'++-- method FontSelectionDialog::get_cancel_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_get_cancel_button" gtk_font_selection_dialog_get_cancel_button :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionDialogGetCancelButton ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogGetCancelButton ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionDialogGetCancelButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_dialog_get_cancel_button _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_get_cancel_button" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelectionDialog::get_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_get_font_name" gtk_font_selection_dialog_get_font_name :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    IO CString++{-# DEPRECATED fontSelectionDialogGetFontName ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogGetFontName ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    m T.Text+fontSelectionDialogGetFontName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_dialog_get_font_name _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_get_font_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FontSelectionDialog::get_font_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_get_font_selection" gtk_font_selection_dialog_get_font_selection :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionDialogGetFontSelection ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogGetFontSelection ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionDialogGetFontSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_dialog_get_font_selection _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_get_font_selection" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelectionDialog::get_ok_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_get_ok_button" gtk_font_selection_dialog_get_ok_button :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    IO (Ptr Widget)++{-# DEPRECATED fontSelectionDialogGetOkButton ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogGetOkButton ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    m Widget+fontSelectionDialogGetOkButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_dialog_get_ok_button _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_get_ok_button" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method FontSelectionDialog::get_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_font_selection_dialog_get_preview_text" gtk_font_selection_dialog_get_preview_text :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    IO CString++{-# DEPRECATED fontSelectionDialogGetPreviewText ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogGetPreviewText ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    m T.Text+fontSelectionDialogGetPreviewText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_font_selection_dialog_get_preview_text _obj'+    checkUnexpectedReturnNULL "gtk_font_selection_dialog_get_preview_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontSelectionDialog::set_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fontname", 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 "gtk_font_selection_dialog_set_font_name" gtk_font_selection_dialog_set_font_name :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    CString ->                              -- fontname : TBasicType TUTF8+    IO CInt++{-# DEPRECATED fontSelectionDialogSetFontName ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogSetFontName ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- fontname+    m Bool+fontSelectionDialogSetFontName _obj fontname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    fontname' <- textToCString fontname+    result <- gtk_font_selection_dialog_set_font_name _obj' fontname'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fontname'+    return result'++-- method FontSelectionDialog::set_preview_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "FontSelectionDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_font_selection_dialog_set_preview_text" gtk_font_selection_dialog_set_preview_text :: +    Ptr FontSelectionDialog ->              -- _obj : TInterface "Gtk" "FontSelectionDialog"+    CString ->                              -- text : TBasicType TUTF8+    IO ()++{-# DEPRECATED fontSelectionDialogSetPreviewText ["(Since version 3.2)","Use #GtkFontChooserDialog"]#-}+fontSelectionDialogSetPreviewText ::+    (MonadIO m, FontSelectionDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+fontSelectionDialogSetPreviewText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_font_selection_dialog_set_preview_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++
+ GI/Gtk/Objects/FontSelectionDialog.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FontSelectionDialog where++import Prelude ()+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 FontSelectionDialog = FontSelectionDialog (ForeignPtr FontSelectionDialog)+instance GObject FontSelectionDialog where+class GObject o => FontSelectionDialogK o+instance (GObject o, IsDescendantOf FontSelectionDialog o) => FontSelectionDialogK o
+ GI/Gtk/Objects/Frame.hs view
@@ -0,0 +1,518 @@++{- |+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.Gtk.Objects.Frame+    ( ++-- * Exported types+    Frame(..)                               ,+    FrameK                                  ,+    toFrame                                 ,+    noFrame                                 ,+++ -- * Methods+-- ** frameGetLabel+    frameGetLabel                           ,+++-- ** frameGetLabelAlign+    frameGetLabelAlign                      ,+++-- ** frameGetLabelWidget+    frameGetLabelWidget                     ,+++-- ** frameGetShadowType+    frameGetShadowType                      ,+++-- ** frameNew+    frameNew                                ,+++-- ** frameSetLabel+    frameSetLabel                           ,+++-- ** frameSetLabelAlign+    frameSetLabelAlign                      ,+++-- ** frameSetLabelWidget+    frameSetLabelWidget                     ,+++-- ** frameSetShadowType+    frameSetShadowType                      ,+++++ -- * Properties+-- ** Label+    FrameLabelPropertyInfo                  ,+    constructFrameLabel                     ,+    getFrameLabel                           ,+    setFrameLabel                           ,+++-- ** LabelWidget+    FrameLabelWidgetPropertyInfo            ,+    constructFrameLabelWidget               ,+    getFrameLabelWidget                     ,+    setFrameLabelWidget                     ,+++-- ** LabelXalign+    FrameLabelXalignPropertyInfo            ,+    constructFrameLabelXalign               ,+    getFrameLabelXalign                     ,+    setFrameLabelXalign                     ,+++-- ** LabelYalign+    FrameLabelYalignPropertyInfo            ,+    constructFrameLabelYalign               ,+    getFrameLabelYalign                     ,+    setFrameLabelYalign                     ,+++-- ** ShadowType+    FrameShadowTypePropertyInfo             ,+    constructFrameShadowType                ,+    getFrameShadowType                      ,+    setFrameShadowType                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Frame = Frame (ForeignPtr Frame)+foreign import ccall "gtk_frame_get_type"+    c_gtk_frame_get_type :: IO GType++type instance ParentTypes Frame = FrameParentTypes+type FrameParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Frame where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_frame_get_type+    ++class GObject o => FrameK o+instance (GObject o, IsDescendantOf Frame o) => FrameK o++toFrame :: FrameK o => o -> IO Frame+toFrame = unsafeCastTo Frame++noFrame :: Maybe Frame+noFrame = Nothing++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getFrameLabel :: (MonadIO m, FrameK o) => o -> m T.Text+getFrameLabel obj = liftIO $ getObjectPropertyString obj "label"++setFrameLabel :: (MonadIO m, FrameK o) => o -> T.Text -> m ()+setFrameLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructFrameLabel :: T.Text -> IO ([Char], GValue)+constructFrameLabel val = constructObjectPropertyString "label" val++data FrameLabelPropertyInfo+instance AttrInfo FrameLabelPropertyInfo where+    type AttrAllowedOps FrameLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FrameLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint FrameLabelPropertyInfo = FrameK+    type AttrGetType FrameLabelPropertyInfo = T.Text+    type AttrLabel FrameLabelPropertyInfo = "Frame::label"+    attrGet _ = getFrameLabel+    attrSet _ = setFrameLabel+    attrConstruct _ = constructFrameLabel++-- VVV Prop "label-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getFrameLabelWidget :: (MonadIO m, FrameK o) => o -> m Widget+getFrameLabelWidget obj = liftIO $ getObjectPropertyObject obj "label-widget" Widget++setFrameLabelWidget :: (MonadIO m, FrameK o, WidgetK a) => o -> a -> m ()+setFrameLabelWidget obj val = liftIO $ setObjectPropertyObject obj "label-widget" val++constructFrameLabelWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructFrameLabelWidget val = constructObjectPropertyObject "label-widget" val++data FrameLabelWidgetPropertyInfo+instance AttrInfo FrameLabelWidgetPropertyInfo where+    type AttrAllowedOps FrameLabelWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FrameLabelWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint FrameLabelWidgetPropertyInfo = FrameK+    type AttrGetType FrameLabelWidgetPropertyInfo = Widget+    type AttrLabel FrameLabelWidgetPropertyInfo = "Frame::label-widget"+    attrGet _ = getFrameLabelWidget+    attrSet _ = setFrameLabelWidget+    attrConstruct _ = constructFrameLabelWidget++-- VVV Prop "label-xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getFrameLabelXalign :: (MonadIO m, FrameK o) => o -> m Float+getFrameLabelXalign obj = liftIO $ getObjectPropertyFloat obj "label-xalign"++setFrameLabelXalign :: (MonadIO m, FrameK o) => o -> Float -> m ()+setFrameLabelXalign obj val = liftIO $ setObjectPropertyFloat obj "label-xalign" val++constructFrameLabelXalign :: Float -> IO ([Char], GValue)+constructFrameLabelXalign val = constructObjectPropertyFloat "label-xalign" val++data FrameLabelXalignPropertyInfo+instance AttrInfo FrameLabelXalignPropertyInfo where+    type AttrAllowedOps FrameLabelXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FrameLabelXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint FrameLabelXalignPropertyInfo = FrameK+    type AttrGetType FrameLabelXalignPropertyInfo = Float+    type AttrLabel FrameLabelXalignPropertyInfo = "Frame::label-xalign"+    attrGet _ = getFrameLabelXalign+    attrSet _ = setFrameLabelXalign+    attrConstruct _ = constructFrameLabelXalign++-- VVV Prop "label-yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getFrameLabelYalign :: (MonadIO m, FrameK o) => o -> m Float+getFrameLabelYalign obj = liftIO $ getObjectPropertyFloat obj "label-yalign"++setFrameLabelYalign :: (MonadIO m, FrameK o) => o -> Float -> m ()+setFrameLabelYalign obj val = liftIO $ setObjectPropertyFloat obj "label-yalign" val++constructFrameLabelYalign :: Float -> IO ([Char], GValue)+constructFrameLabelYalign val = constructObjectPropertyFloat "label-yalign" val++data FrameLabelYalignPropertyInfo+instance AttrInfo FrameLabelYalignPropertyInfo where+    type AttrAllowedOps FrameLabelYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FrameLabelYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint FrameLabelYalignPropertyInfo = FrameK+    type AttrGetType FrameLabelYalignPropertyInfo = Float+    type AttrLabel FrameLabelYalignPropertyInfo = "Frame::label-yalign"+    attrGet _ = getFrameLabelYalign+    attrSet _ = setFrameLabelYalign+    attrConstruct _ = constructFrameLabelYalign++-- VVV Prop "shadow-type"+   -- Type: TInterface "Gtk" "ShadowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getFrameShadowType :: (MonadIO m, FrameK o) => o -> m ShadowType+getFrameShadowType obj = liftIO $ getObjectPropertyEnum obj "shadow-type"++setFrameShadowType :: (MonadIO m, FrameK o) => o -> ShadowType -> m ()+setFrameShadowType obj val = liftIO $ setObjectPropertyEnum obj "shadow-type" val++constructFrameShadowType :: ShadowType -> IO ([Char], GValue)+constructFrameShadowType val = constructObjectPropertyEnum "shadow-type" val++data FrameShadowTypePropertyInfo+instance AttrInfo FrameShadowTypePropertyInfo where+    type AttrAllowedOps FrameShadowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint FrameShadowTypePropertyInfo = (~) ShadowType+    type AttrBaseTypeConstraint FrameShadowTypePropertyInfo = FrameK+    type AttrGetType FrameShadowTypePropertyInfo = ShadowType+    type AttrLabel FrameShadowTypePropertyInfo = "Frame::shadow-type"+    attrGet _ = getFrameShadowType+    attrSet _ = setFrameShadowType+    attrConstruct _ = constructFrameShadowType++type instance AttributeList Frame = FrameAttributeList+type FrameAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", FrameLabelPropertyInfo), '("label-widget", FrameLabelWidgetPropertyInfo), '("label-xalign", FrameLabelXalignPropertyInfo), '("label-yalign", FrameLabelYalignPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", FrameShadowTypePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Frame = FrameSignalList+type FrameSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Frame::new+-- method type : Constructor+-- Args : [Arg {argName = "label", 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}]+-- returnType : TInterface "Gtk" "Frame"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_new" gtk_frame_new :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Frame)+++frameNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- label+    m Frame+frameNew label = liftIO $ do+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_frame_new maybeLabel+    checkUnexpectedReturnNULL "gtk_frame_new" result+    result' <- (newObject Frame) result+    freeMem maybeLabel+    return result'++-- method Frame::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_get_label" gtk_frame_get_label :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    IO CString+++frameGetLabel ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    m T.Text+frameGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_frame_get_label _obj'+    checkUnexpectedReturnNULL "gtk_frame_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Frame::get_label_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_get_label_align" gtk_frame_get_label_align :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    Ptr CFloat ->                           -- xalign : TBasicType TFloat+    Ptr CFloat ->                           -- yalign : TBasicType TFloat+    IO ()+++frameGetLabelAlign ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    m (Float,Float)+frameGetLabelAlign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xalign <- allocMem :: IO (Ptr CFloat)+    yalign <- allocMem :: IO (Ptr CFloat)+    gtk_frame_get_label_align _obj' xalign yalign+    xalign' <- peek xalign+    let xalign'' = realToFrac xalign'+    yalign' <- peek yalign+    let yalign'' = realToFrac yalign'+    touchManagedPtr _obj+    freeMem xalign+    freeMem yalign+    return (xalign'', yalign'')++-- method Frame::get_label_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_get_label_widget" gtk_frame_get_label_widget :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    IO (Ptr Widget)+++frameGetLabelWidget ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    m Widget+frameGetLabelWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_frame_get_label_widget _obj'+    checkUnexpectedReturnNULL "gtk_frame_get_label_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Frame::get_shadow_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ShadowType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_get_shadow_type" gtk_frame_get_shadow_type :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    IO CUInt+++frameGetShadowType ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    m ShadowType+frameGetShadowType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_frame_get_shadow_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Frame::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", 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 "Gtk" "Frame", 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 "gtk_frame_set_label" gtk_frame_set_label :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++frameSetLabel ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+frameSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    gtk_frame_set_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method Frame::set_label_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_set_label_align" gtk_frame_set_label_align :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    IO ()+++frameSetLabelAlign ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    m ()+frameSetLabelAlign _obj xalign yalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    gtk_frame_set_label_align _obj' xalign' yalign'+    touchManagedPtr _obj+    return ()++-- method Frame::set_label_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_set_label_widget" gtk_frame_set_label_widget :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    Ptr Widget ->                           -- label_widget : TInterface "Gtk" "Widget"+    IO ()+++frameSetLabelWidget ::+    (MonadIO m, FrameK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- label_widget+    m ()+frameSetLabelWidget _obj label_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel_widget <- case label_widget of+        Nothing -> return nullPtr+        Just jLabel_widget -> do+            let jLabel_widget' = unsafeManagedPtrCastPtr jLabel_widget+            return jLabel_widget'+    gtk_frame_set_label_widget _obj' maybeLabel_widget+    touchManagedPtr _obj+    whenJust label_widget touchManagedPtr+    return ()++-- method Frame::set_shadow_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Frame", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_frame_set_shadow_type" gtk_frame_set_shadow_type :: +    Ptr Frame ->                            -- _obj : TInterface "Gtk" "Frame"+    CUInt ->                                -- type : TInterface "Gtk" "ShadowType"+    IO ()+++frameSetShadowType ::+    (MonadIO m, FrameK a) =>+    a ->                                    -- _obj+    ShadowType ->                           -- type+    m ()+frameSetShadowType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    gtk_frame_set_shadow_type _obj' type_'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Frame.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.Frame where++import Prelude ()+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 Frame = Frame (ForeignPtr Frame)+instance GObject Frame where+class GObject o => FrameK o+instance (GObject o, IsDescendantOf Frame o) => FrameK o+data FrameLabelPropertyInfo+data FrameLabelWidgetPropertyInfo+data FrameLabelXalignPropertyInfo+data FrameLabelYalignPropertyInfo+data FrameShadowTypePropertyInfo
+ GI/Gtk/Objects/FrameAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.FrameAccessible+    ( ++-- * Exported types+    FrameAccessible(..)                     ,+    FrameAccessibleK                        ,+    toFrameAccessible                       ,+    noFrameAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype FrameAccessible = FrameAccessible (ForeignPtr FrameAccessible)+foreign import ccall "gtk_frame_accessible_get_type"+    c_gtk_frame_accessible_get_type :: IO GType++type instance ParentTypes FrameAccessible = FrameAccessibleParentTypes+type FrameAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component]++instance GObject FrameAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_frame_accessible_get_type+    ++class GObject o => FrameAccessibleK o+instance (GObject o, IsDescendantOf FrameAccessible o) => FrameAccessibleK o++toFrameAccessible :: FrameAccessibleK o => o -> IO FrameAccessible+toFrameAccessible = unsafeCastTo FrameAccessible++noFrameAccessible :: Maybe FrameAccessible+noFrameAccessible = Nothing++type instance AttributeList FrameAccessible = FrameAccessibleAttributeList+type FrameAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList FrameAccessible = FrameAccessibleSignalList+type FrameAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/FrameAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.FrameAccessible where++import Prelude ()+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 FrameAccessible = FrameAccessible (ForeignPtr FrameAccessible)+instance GObject FrameAccessible where+class GObject o => FrameAccessibleK o+instance (GObject o, IsDescendantOf FrameAccessible o) => FrameAccessibleK o
+ GI/Gtk/Objects/GLArea.hs view
@@ -0,0 +1,909 @@++{- |+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.Gtk.Objects.GLArea+    ( ++-- * Exported types+    GLArea(..)                              ,+    GLAreaK                                 ,+    toGLArea                                ,+    noGLArea                                ,+++ -- * Methods+-- ** gLAreaAttachBuffers+    gLAreaAttachBuffers                     ,+++-- ** gLAreaGetAutoRender+    gLAreaGetAutoRender                     ,+++-- ** gLAreaGetContext+    gLAreaGetContext                        ,+++-- ** gLAreaGetError+    gLAreaGetError                          ,+++-- ** gLAreaGetHasAlpha+    gLAreaGetHasAlpha                       ,+++-- ** gLAreaGetHasDepthBuffer+    gLAreaGetHasDepthBuffer                 ,+++-- ** gLAreaGetHasStencilBuffer+    gLAreaGetHasStencilBuffer               ,+++-- ** gLAreaGetRequiredVersion+    gLAreaGetRequiredVersion                ,+++-- ** gLAreaMakeCurrent+    gLAreaMakeCurrent                       ,+++-- ** gLAreaNew+    gLAreaNew                               ,+++-- ** gLAreaQueueRender+    gLAreaQueueRender                       ,+++-- ** gLAreaSetAutoRender+    gLAreaSetAutoRender                     ,+++-- ** gLAreaSetError+    gLAreaSetError                          ,+++-- ** gLAreaSetHasAlpha+    gLAreaSetHasAlpha                       ,+++-- ** gLAreaSetHasDepthBuffer+    gLAreaSetHasDepthBuffer                 ,+++-- ** gLAreaSetHasStencilBuffer+    gLAreaSetHasStencilBuffer               ,+++-- ** gLAreaSetRequiredVersion+    gLAreaSetRequiredVersion                ,+++++ -- * Properties+-- ** AutoRender+    GLAreaAutoRenderPropertyInfo            ,+    constructGLAreaAutoRender               ,+    getGLAreaAutoRender                     ,+    setGLAreaAutoRender                     ,+++-- ** Context+    GLAreaContextPropertyInfo               ,+    getGLAreaContext                        ,+++-- ** HasAlpha+    GLAreaHasAlphaPropertyInfo              ,+    constructGLAreaHasAlpha                 ,+    getGLAreaHasAlpha                       ,+    setGLAreaHasAlpha                       ,+++-- ** HasDepthBuffer+    GLAreaHasDepthBufferPropertyInfo        ,+    constructGLAreaHasDepthBuffer           ,+    getGLAreaHasDepthBuffer                 ,+    setGLAreaHasDepthBuffer                 ,+++-- ** HasStencilBuffer+    GLAreaHasStencilBufferPropertyInfo      ,+    constructGLAreaHasStencilBuffer         ,+    getGLAreaHasStencilBuffer               ,+    setGLAreaHasStencilBuffer               ,+++++ -- * Signals+-- ** CreateContext+    GLAreaCreateContextCallback             ,+    GLAreaCreateContextCallbackC            ,+    GLAreaCreateContextSignalInfo           ,+    afterGLAreaCreateContext                ,+    gLAreaCreateContextCallbackWrapper      ,+    gLAreaCreateContextClosure              ,+    mkGLAreaCreateContextCallback           ,+    noGLAreaCreateContextCallback           ,+    onGLAreaCreateContext                   ,+++-- ** Render+    GLAreaRenderCallback                    ,+    GLAreaRenderCallbackC                   ,+    GLAreaRenderSignalInfo                  ,+    afterGLAreaRender                       ,+    gLAreaRenderCallbackWrapper             ,+    gLAreaRenderClosure                     ,+    mkGLAreaRenderCallback                  ,+    noGLAreaRenderCallback                  ,+    onGLAreaRender                          ,+++-- ** Resize+    GLAreaResizeCallback                    ,+    GLAreaResizeCallbackC                   ,+    GLAreaResizeSignalInfo                  ,+    afterGLAreaResize                       ,+    gLAreaResizeCallbackWrapper             ,+    gLAreaResizeClosure                     ,+    mkGLAreaResizeCallback                  ,+    noGLAreaResizeCallback                  ,+    onGLAreaResize                          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype GLArea = GLArea (ForeignPtr GLArea)+foreign import ccall "gtk_gl_area_get_type"+    c_gtk_gl_area_get_type :: IO GType++type instance ParentTypes GLArea = GLAreaParentTypes+type GLAreaParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject GLArea where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_gl_area_get_type+    ++class GObject o => GLAreaK o+instance (GObject o, IsDescendantOf GLArea o) => GLAreaK o++toGLArea :: GLAreaK o => o -> IO GLArea+toGLArea = unsafeCastTo GLArea++noGLArea :: Maybe GLArea+noGLArea = Nothing++-- signal GLArea::create-context+type GLAreaCreateContextCallback =+    IO Gdk.GLContext++noGLAreaCreateContextCallback :: Maybe GLAreaCreateContextCallback+noGLAreaCreateContextCallback = Nothing++type GLAreaCreateContextCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO (Ptr Gdk.GLContext)++foreign import ccall "wrapper"+    mkGLAreaCreateContextCallback :: GLAreaCreateContextCallbackC -> IO (FunPtr GLAreaCreateContextCallbackC)++gLAreaCreateContextClosure :: GLAreaCreateContextCallback -> IO Closure+gLAreaCreateContextClosure cb = newCClosure =<< mkGLAreaCreateContextCallback wrapped+    where wrapped = gLAreaCreateContextCallbackWrapper cb++gLAreaCreateContextCallbackWrapper ::+    GLAreaCreateContextCallback ->+    Ptr () ->+    Ptr () ->+    IO (Ptr Gdk.GLContext)+gLAreaCreateContextCallbackWrapper _cb _ _ = do+    result <- _cb +    result' <- refObject result+    return result'++onGLAreaCreateContext :: (GObject a, MonadIO m) => a -> GLAreaCreateContextCallback -> m SignalHandlerId+onGLAreaCreateContext obj cb = liftIO $ connectGLAreaCreateContext obj cb SignalConnectBefore+afterGLAreaCreateContext :: (GObject a, MonadIO m) => a -> GLAreaCreateContextCallback -> m SignalHandlerId+afterGLAreaCreateContext obj cb = connectGLAreaCreateContext obj cb SignalConnectAfter++connectGLAreaCreateContext :: (GObject a, MonadIO m) =>+                              a -> GLAreaCreateContextCallback -> SignalConnectMode -> m SignalHandlerId+connectGLAreaCreateContext obj cb after = liftIO $ do+    cb' <- mkGLAreaCreateContextCallback (gLAreaCreateContextCallbackWrapper cb)+    connectSignalFunPtr obj "create-context" cb' after++-- signal GLArea::render+type GLAreaRenderCallback =+    Gdk.GLContext ->+    IO Bool++noGLAreaRenderCallback :: Maybe GLAreaRenderCallback+noGLAreaRenderCallback = Nothing++type GLAreaRenderCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.GLContext ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkGLAreaRenderCallback :: GLAreaRenderCallbackC -> IO (FunPtr GLAreaRenderCallbackC)++gLAreaRenderClosure :: GLAreaRenderCallback -> IO Closure+gLAreaRenderClosure cb = newCClosure =<< mkGLAreaRenderCallback wrapped+    where wrapped = gLAreaRenderCallbackWrapper cb++gLAreaRenderCallbackWrapper ::+    GLAreaRenderCallback ->+    Ptr () ->+    Ptr Gdk.GLContext ->+    Ptr () ->+    IO CInt+gLAreaRenderCallbackWrapper _cb _ context _ = do+    context' <- (newObject Gdk.GLContext) context+    result <- _cb  context'+    let result' = (fromIntegral . fromEnum) result+    return result'++onGLAreaRender :: (GObject a, MonadIO m) => a -> GLAreaRenderCallback -> m SignalHandlerId+onGLAreaRender obj cb = liftIO $ connectGLAreaRender obj cb SignalConnectBefore+afterGLAreaRender :: (GObject a, MonadIO m) => a -> GLAreaRenderCallback -> m SignalHandlerId+afterGLAreaRender obj cb = connectGLAreaRender obj cb SignalConnectAfter++connectGLAreaRender :: (GObject a, MonadIO m) =>+                       a -> GLAreaRenderCallback -> SignalConnectMode -> m SignalHandlerId+connectGLAreaRender obj cb after = liftIO $ do+    cb' <- mkGLAreaRenderCallback (gLAreaRenderCallbackWrapper cb)+    connectSignalFunPtr obj "render" cb' after++-- signal GLArea::resize+type GLAreaResizeCallback =+    Int32 ->+    Int32 ->+    IO ()++noGLAreaResizeCallback :: Maybe GLAreaResizeCallback+noGLAreaResizeCallback = Nothing++type GLAreaResizeCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGLAreaResizeCallback :: GLAreaResizeCallbackC -> IO (FunPtr GLAreaResizeCallbackC)++gLAreaResizeClosure :: GLAreaResizeCallback -> IO Closure+gLAreaResizeClosure cb = newCClosure =<< mkGLAreaResizeCallback wrapped+    where wrapped = gLAreaResizeCallbackWrapper cb++gLAreaResizeCallbackWrapper ::+    GLAreaResizeCallback ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Ptr () ->+    IO ()+gLAreaResizeCallbackWrapper _cb _ width height _ = do+    _cb  width height++onGLAreaResize :: (GObject a, MonadIO m) => a -> GLAreaResizeCallback -> m SignalHandlerId+onGLAreaResize obj cb = liftIO $ connectGLAreaResize obj cb SignalConnectBefore+afterGLAreaResize :: (GObject a, MonadIO m) => a -> GLAreaResizeCallback -> m SignalHandlerId+afterGLAreaResize obj cb = connectGLAreaResize obj cb SignalConnectAfter++connectGLAreaResize :: (GObject a, MonadIO m) =>+                       a -> GLAreaResizeCallback -> SignalConnectMode -> m SignalHandlerId+connectGLAreaResize obj cb after = liftIO $ do+    cb' <- mkGLAreaResizeCallback (gLAreaResizeCallbackWrapper cb)+    connectSignalFunPtr obj "resize" cb' after++-- VVV Prop "auto-render"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGLAreaAutoRender :: (MonadIO m, GLAreaK o) => o -> m Bool+getGLAreaAutoRender obj = liftIO $ getObjectPropertyBool obj "auto-render"++setGLAreaAutoRender :: (MonadIO m, GLAreaK o) => o -> Bool -> m ()+setGLAreaAutoRender obj val = liftIO $ setObjectPropertyBool obj "auto-render" val++constructGLAreaAutoRender :: Bool -> IO ([Char], GValue)+constructGLAreaAutoRender val = constructObjectPropertyBool "auto-render" val++data GLAreaAutoRenderPropertyInfo+instance AttrInfo GLAreaAutoRenderPropertyInfo where+    type AttrAllowedOps GLAreaAutoRenderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GLAreaAutoRenderPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GLAreaAutoRenderPropertyInfo = GLAreaK+    type AttrGetType GLAreaAutoRenderPropertyInfo = Bool+    type AttrLabel GLAreaAutoRenderPropertyInfo = "GLArea::auto-render"+    attrGet _ = getGLAreaAutoRender+    attrSet _ = setGLAreaAutoRender+    attrConstruct _ = constructGLAreaAutoRender++-- VVV Prop "context"+   -- Type: TInterface "Gdk" "GLContext"+   -- Flags: [PropertyReadable]++getGLAreaContext :: (MonadIO m, GLAreaK o) => o -> m Gdk.GLContext+getGLAreaContext obj = liftIO $ getObjectPropertyObject obj "context" Gdk.GLContext++data GLAreaContextPropertyInfo+instance AttrInfo GLAreaContextPropertyInfo where+    type AttrAllowedOps GLAreaContextPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint GLAreaContextPropertyInfo = (~) ()+    type AttrBaseTypeConstraint GLAreaContextPropertyInfo = GLAreaK+    type AttrGetType GLAreaContextPropertyInfo = Gdk.GLContext+    type AttrLabel GLAreaContextPropertyInfo = "GLArea::context"+    attrGet _ = getGLAreaContext+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "has-alpha"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGLAreaHasAlpha :: (MonadIO m, GLAreaK o) => o -> m Bool+getGLAreaHasAlpha obj = liftIO $ getObjectPropertyBool obj "has-alpha"++setGLAreaHasAlpha :: (MonadIO m, GLAreaK o) => o -> Bool -> m ()+setGLAreaHasAlpha obj val = liftIO $ setObjectPropertyBool obj "has-alpha" val++constructGLAreaHasAlpha :: Bool -> IO ([Char], GValue)+constructGLAreaHasAlpha val = constructObjectPropertyBool "has-alpha" val++data GLAreaHasAlphaPropertyInfo+instance AttrInfo GLAreaHasAlphaPropertyInfo where+    type AttrAllowedOps GLAreaHasAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GLAreaHasAlphaPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GLAreaHasAlphaPropertyInfo = GLAreaK+    type AttrGetType GLAreaHasAlphaPropertyInfo = Bool+    type AttrLabel GLAreaHasAlphaPropertyInfo = "GLArea::has-alpha"+    attrGet _ = getGLAreaHasAlpha+    attrSet _ = setGLAreaHasAlpha+    attrConstruct _ = constructGLAreaHasAlpha++-- VVV Prop "has-depth-buffer"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGLAreaHasDepthBuffer :: (MonadIO m, GLAreaK o) => o -> m Bool+getGLAreaHasDepthBuffer obj = liftIO $ getObjectPropertyBool obj "has-depth-buffer"++setGLAreaHasDepthBuffer :: (MonadIO m, GLAreaK o) => o -> Bool -> m ()+setGLAreaHasDepthBuffer obj val = liftIO $ setObjectPropertyBool obj "has-depth-buffer" val++constructGLAreaHasDepthBuffer :: Bool -> IO ([Char], GValue)+constructGLAreaHasDepthBuffer val = constructObjectPropertyBool "has-depth-buffer" val++data GLAreaHasDepthBufferPropertyInfo+instance AttrInfo GLAreaHasDepthBufferPropertyInfo where+    type AttrAllowedOps GLAreaHasDepthBufferPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GLAreaHasDepthBufferPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GLAreaHasDepthBufferPropertyInfo = GLAreaK+    type AttrGetType GLAreaHasDepthBufferPropertyInfo = Bool+    type AttrLabel GLAreaHasDepthBufferPropertyInfo = "GLArea::has-depth-buffer"+    attrGet _ = getGLAreaHasDepthBuffer+    attrSet _ = setGLAreaHasDepthBuffer+    attrConstruct _ = constructGLAreaHasDepthBuffer++-- VVV Prop "has-stencil-buffer"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGLAreaHasStencilBuffer :: (MonadIO m, GLAreaK o) => o -> m Bool+getGLAreaHasStencilBuffer obj = liftIO $ getObjectPropertyBool obj "has-stencil-buffer"++setGLAreaHasStencilBuffer :: (MonadIO m, GLAreaK o) => o -> Bool -> m ()+setGLAreaHasStencilBuffer obj val = liftIO $ setObjectPropertyBool obj "has-stencil-buffer" val++constructGLAreaHasStencilBuffer :: Bool -> IO ([Char], GValue)+constructGLAreaHasStencilBuffer val = constructObjectPropertyBool "has-stencil-buffer" val++data GLAreaHasStencilBufferPropertyInfo+instance AttrInfo GLAreaHasStencilBufferPropertyInfo where+    type AttrAllowedOps GLAreaHasStencilBufferPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GLAreaHasStencilBufferPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GLAreaHasStencilBufferPropertyInfo = GLAreaK+    type AttrGetType GLAreaHasStencilBufferPropertyInfo = Bool+    type AttrLabel GLAreaHasStencilBufferPropertyInfo = "GLArea::has-stencil-buffer"+    attrGet _ = getGLAreaHasStencilBuffer+    attrSet _ = setGLAreaHasStencilBuffer+    attrConstruct _ = constructGLAreaHasStencilBuffer++type instance AttributeList GLArea = GLAreaAttributeList+type GLAreaAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("auto-render", GLAreaAutoRenderPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("context", GLAreaContextPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-alpha", GLAreaHasAlphaPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-depth-buffer", GLAreaHasDepthBufferPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-stencil-buffer", GLAreaHasStencilBufferPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data GLAreaCreateContextSignalInfo+instance SignalInfo GLAreaCreateContextSignalInfo where+    type HaskellCallbackType GLAreaCreateContextSignalInfo = GLAreaCreateContextCallback+    connectSignal _ = connectGLAreaCreateContext++data GLAreaRenderSignalInfo+instance SignalInfo GLAreaRenderSignalInfo where+    type HaskellCallbackType GLAreaRenderSignalInfo = GLAreaRenderCallback+    connectSignal _ = connectGLAreaRender++data GLAreaResizeSignalInfo+instance SignalInfo GLAreaResizeSignalInfo where+    type HaskellCallbackType GLAreaResizeSignalInfo = GLAreaResizeCallback+    connectSignal _ = connectGLAreaResize++type instance SignalList GLArea = GLAreaSignalList+type GLAreaSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("create-context", GLAreaCreateContextSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("render", GLAreaRenderSignalInfo), '("resize", GLAreaResizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GLArea::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "GLArea"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_new" gtk_gl_area_new :: +    IO (Ptr GLArea)+++gLAreaNew ::+    (MonadIO m) =>+    m GLArea+gLAreaNew  = liftIO $ do+    result <- gtk_gl_area_new+    checkUnexpectedReturnNULL "gtk_gl_area_new" result+    result' <- (wrapObject GLArea) result+    return result'++-- method GLArea::attach_buffers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_attach_buffers" gtk_gl_area_attach_buffers :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO ()+++gLAreaAttachBuffers ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m ()+gLAreaAttachBuffers _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gl_area_attach_buffers _obj'+    touchManagedPtr _obj+    return ()++-- method GLArea::get_auto_render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_auto_render" gtk_gl_area_get_auto_render :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO CInt+++gLAreaGetAutoRender ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m Bool+gLAreaGetAutoRender _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_auto_render _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "GLContext"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_context" gtk_gl_area_get_context :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO (Ptr Gdk.GLContext)+++gLAreaGetContext ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m Gdk.GLContext+gLAreaGetContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_context _obj'+    checkUnexpectedReturnNULL "gtk_gl_area_get_context" result+    result' <- (newObject Gdk.GLContext) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TError+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_error" gtk_gl_area_get_error :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO (Ptr GError)+++gLAreaGetError ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m GError+gLAreaGetError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_error _obj'+    checkUnexpectedReturnNULL "gtk_gl_area_get_error" result+    result' <- (newBoxed GError) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_has_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_has_alpha" gtk_gl_area_get_has_alpha :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO CInt+++gLAreaGetHasAlpha ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m Bool+gLAreaGetHasAlpha _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_has_alpha _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_has_depth_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_has_depth_buffer" gtk_gl_area_get_has_depth_buffer :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO CInt+++gLAreaGetHasDepthBuffer ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m Bool+gLAreaGetHasDepthBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_has_depth_buffer _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_has_stencil_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_has_stencil_buffer" gtk_gl_area_get_has_stencil_buffer :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO CInt+++gLAreaGetHasStencilBuffer ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m Bool+gLAreaGetHasStencilBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gl_area_get_has_stencil_buffer _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GLArea::get_required_version+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "major", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "minor", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_get_required_version" gtk_gl_area_get_required_version :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    Ptr Int32 ->                            -- major : TBasicType TInt32+    Ptr Int32 ->                            -- minor : TBasicType TInt32+    IO ()+++gLAreaGetRequiredVersion ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+gLAreaGetRequiredVersion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    major <- allocMem :: IO (Ptr Int32)+    minor <- allocMem :: IO (Ptr Int32)+    gtk_gl_area_get_required_version _obj' major minor+    major' <- peek major+    minor' <- peek minor+    touchManagedPtr _obj+    freeMem major+    freeMem minor+    return (major', minor')++-- method GLArea::make_current+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_make_current" gtk_gl_area_make_current :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO ()+++gLAreaMakeCurrent ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m ()+gLAreaMakeCurrent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gl_area_make_current _obj'+    touchManagedPtr _obj+    return ()++-- method GLArea::queue_render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_queue_render" gtk_gl_area_queue_render :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    IO ()+++gLAreaQueueRender ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    m ()+gLAreaQueueRender _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gl_area_queue_render _obj'+    touchManagedPtr _obj+    return ()++-- method GLArea::set_auto_render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auto_render", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auto_render", 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 "gtk_gl_area_set_auto_render" gtk_gl_area_set_auto_render :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    CInt ->                                 -- auto_render : TBasicType TBoolean+    IO ()+++gLAreaSetAutoRender ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- auto_render+    m ()+gLAreaSetAutoRender _obj auto_render = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let auto_render' = (fromIntegral . fromEnum) auto_render+    gtk_gl_area_set_auto_render _obj' auto_render'+    touchManagedPtr _obj+    return ()++-- method GLArea::set_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error", argType = TError, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gl_area_set_error" gtk_gl_area_set_error :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    Ptr GError ->                           -- error : TError+    IO ()+++gLAreaSetError ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Maybe (GError) ->                       -- error+    m ()+gLAreaSetError _obj error_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeError_ <- case error_ of+        Nothing -> return nullPtr+        Just jError_ -> do+            let jError_' = unsafeManagedPtrGetPtr jError_+            return jError_'+    gtk_gl_area_set_error _obj' maybeError_+    touchManagedPtr _obj+    whenJust error_ touchManagedPtr+    return ()++-- method GLArea::set_has_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_alpha", 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 "gtk_gl_area_set_has_alpha" gtk_gl_area_set_has_alpha :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    CInt ->                                 -- has_alpha : TBasicType TBoolean+    IO ()+++gLAreaSetHasAlpha ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_alpha+    m ()+gLAreaSetHasAlpha _obj has_alpha = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_alpha' = (fromIntegral . fromEnum) has_alpha+    gtk_gl_area_set_has_alpha _obj' has_alpha'+    touchManagedPtr _obj+    return ()++-- method GLArea::set_has_depth_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_depth_buffer", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_depth_buffer", 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 "gtk_gl_area_set_has_depth_buffer" gtk_gl_area_set_has_depth_buffer :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    CInt ->                                 -- has_depth_buffer : TBasicType TBoolean+    IO ()+++gLAreaSetHasDepthBuffer ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_depth_buffer+    m ()+gLAreaSetHasDepthBuffer _obj has_depth_buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_depth_buffer' = (fromIntegral . fromEnum) has_depth_buffer+    gtk_gl_area_set_has_depth_buffer _obj' has_depth_buffer'+    touchManagedPtr _obj+    return ()++-- method GLArea::set_has_stencil_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_stencil_buffer", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_stencil_buffer", 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 "gtk_gl_area_set_has_stencil_buffer" gtk_gl_area_set_has_stencil_buffer :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    CInt ->                                 -- has_stencil_buffer : TBasicType TBoolean+    IO ()+++gLAreaSetHasStencilBuffer ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_stencil_buffer+    m ()+gLAreaSetHasStencilBuffer _obj has_stencil_buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_stencil_buffer' = (fromIntegral . fromEnum) has_stencil_buffer+    gtk_gl_area_set_has_stencil_buffer _obj' has_stencil_buffer'+    touchManagedPtr _obj+    return ()++-- method GLArea::set_required_version+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "major", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minor", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GLArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "major", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "minor", 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 "gtk_gl_area_set_required_version" gtk_gl_area_set_required_version :: +    Ptr GLArea ->                           -- _obj : TInterface "Gtk" "GLArea"+    Int32 ->                                -- major : TBasicType TInt32+    Int32 ->                                -- minor : TBasicType TInt32+    IO ()+++gLAreaSetRequiredVersion ::+    (MonadIO m, GLAreaK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- major+    Int32 ->                                -- minor+    m ()+gLAreaSetRequiredVersion _obj major minor = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gl_area_set_required_version _obj' major minor+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/GLArea.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.GLArea where++import Prelude ()+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 GLArea = GLArea (ForeignPtr GLArea)+instance GObject GLArea where+class GObject o => GLAreaK o+instance (GObject o, IsDescendantOf GLArea o) => GLAreaK o+data GLAreaAutoRenderPropertyInfo+data GLAreaContextPropertyInfo+data GLAreaHasAlphaPropertyInfo+data GLAreaHasDepthBufferPropertyInfo+data GLAreaHasStencilBufferPropertyInfo+data GLAreaCreateContextSignalInfo+data GLAreaRenderSignalInfo+data GLAreaResizeSignalInfo
+ GI/Gtk/Objects/Gesture.hs view
@@ -0,0 +1,1052 @@++{- |+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.Gtk.Objects.Gesture+    ( ++-- * Exported types+    Gesture(..)                             ,+    GestureK                                ,+    toGesture                               ,+    noGesture                               ,+++ -- * Methods+-- ** gestureGetBoundingBox+    gestureGetBoundingBox                   ,+++-- ** gestureGetBoundingBoxCenter+    gestureGetBoundingBoxCenter             ,+++-- ** gestureGetDevice+    gestureGetDevice                        ,+++-- ** gestureGetGroup+    gestureGetGroup                         ,+++-- ** gestureGetLastEvent+    gestureGetLastEvent                     ,+++-- ** gestureGetLastUpdatedSequence+    gestureGetLastUpdatedSequence           ,+++-- ** gestureGetPoint+    gestureGetPoint                         ,+++-- ** gestureGetSequenceState+    gestureGetSequenceState                 ,+++-- ** gestureGetSequences+    gestureGetSequences                     ,+++-- ** gestureGetWindow+    gestureGetWindow                        ,+++-- ** gestureGroup+    gestureGroup                            ,+++-- ** gestureHandlesSequence+    gestureHandlesSequence                  ,+++-- ** gestureIsActive+    gestureIsActive                         ,+++-- ** gestureIsGroupedWith+    gestureIsGroupedWith                    ,+++-- ** gestureIsRecognized+    gestureIsRecognized                     ,+++-- ** gestureSetSequenceState+    gestureSetSequenceState                 ,+++-- ** gestureSetState+    gestureSetState                         ,+++-- ** gestureSetWindow+    gestureSetWindow                        ,+++-- ** gestureUngroup+    gestureUngroup                          ,+++++ -- * Properties+-- ** NPoints+    GestureNPointsPropertyInfo              ,+    constructGestureNPoints                 ,+    getGestureNPoints                       ,+++-- ** Window+    GestureWindowPropertyInfo               ,+    constructGestureWindow                  ,+    getGestureWindow                        ,+    setGestureWindow                        ,+++++ -- * Signals+-- ** Begin+    GestureBeginCallback                    ,+    GestureBeginCallbackC                   ,+    GestureBeginSignalInfo                  ,+    afterGestureBegin                       ,+    gestureBeginCallbackWrapper             ,+    gestureBeginClosure                     ,+    mkGestureBeginCallback                  ,+    noGestureBeginCallback                  ,+    onGestureBegin                          ,+++-- ** Cancel+    GestureCancelCallback                   ,+    GestureCancelCallbackC                  ,+    GestureCancelSignalInfo                 ,+    afterGestureCancel                      ,+    gestureCancelCallbackWrapper            ,+    gestureCancelClosure                    ,+    mkGestureCancelCallback                 ,+    noGestureCancelCallback                 ,+    onGestureCancel                         ,+++-- ** End+    GestureEndCallback                      ,+    GestureEndCallbackC                     ,+    GestureEndSignalInfo                    ,+    afterGestureEnd                         ,+    gestureEndCallbackWrapper               ,+    gestureEndClosure                       ,+    mkGestureEndCallback                    ,+    noGestureEndCallback                    ,+    onGestureEnd                            ,+++-- ** SequenceStateChanged+    GestureSequenceStateChangedCallback     ,+    GestureSequenceStateChangedCallbackC    ,+    GestureSequenceStateChangedSignalInfo   ,+    afterGestureSequenceStateChanged        ,+    gestureSequenceStateChangedCallbackWrapper,+    gestureSequenceStateChangedClosure      ,+    mkGestureSequenceStateChangedCallback   ,+    noGestureSequenceStateChangedCallback   ,+    onGestureSequenceStateChanged           ,+++-- ** Update+    GestureUpdateCallback                   ,+    GestureUpdateCallbackC                  ,+    GestureUpdateSignalInfo                 ,+    afterGestureUpdate                      ,+    gestureUpdateCallbackWrapper            ,+    gestureUpdateClosure                    ,+    mkGestureUpdateCallback                 ,+    noGestureUpdateCallback                 ,+    onGestureUpdate                         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Gesture = Gesture (ForeignPtr Gesture)+foreign import ccall "gtk_gesture_get_type"+    c_gtk_gesture_get_type :: IO GType++type instance ParentTypes Gesture = GestureParentTypes+type GestureParentTypes = '[EventController, GObject.Object]++instance GObject Gesture where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_get_type+    ++class GObject o => GestureK o+instance (GObject o, IsDescendantOf Gesture o) => GestureK o++toGesture :: GestureK o => o -> IO Gesture+toGesture = unsafeCastTo Gesture++noGesture :: Maybe Gesture+noGesture = Nothing++-- signal Gesture::begin+type GestureBeginCallback =+    Gdk.EventSequence ->+    IO ()++noGestureBeginCallback :: Maybe GestureBeginCallback+noGestureBeginCallback = Nothing++type GestureBeginCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventSequence ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureBeginCallback :: GestureBeginCallbackC -> IO (FunPtr GestureBeginCallbackC)++gestureBeginClosure :: GestureBeginCallback -> IO Closure+gestureBeginClosure cb = newCClosure =<< mkGestureBeginCallback wrapped+    where wrapped = gestureBeginCallbackWrapper cb++gestureBeginCallbackWrapper ::+    GestureBeginCallback ->+    Ptr () ->+    Ptr Gdk.EventSequence ->+    Ptr () ->+    IO ()+gestureBeginCallbackWrapper _cb _ sequence _ = do+    sequence' <- (newBoxed Gdk.EventSequence) sequence+    _cb  sequence'++onGestureBegin :: (GObject a, MonadIO m) => a -> GestureBeginCallback -> m SignalHandlerId+onGestureBegin obj cb = liftIO $ connectGestureBegin obj cb SignalConnectBefore+afterGestureBegin :: (GObject a, MonadIO m) => a -> GestureBeginCallback -> m SignalHandlerId+afterGestureBegin obj cb = connectGestureBegin obj cb SignalConnectAfter++connectGestureBegin :: (GObject a, MonadIO m) =>+                       a -> GestureBeginCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureBegin obj cb after = liftIO $ do+    cb' <- mkGestureBeginCallback (gestureBeginCallbackWrapper cb)+    connectSignalFunPtr obj "begin" cb' after++-- signal Gesture::cancel+type GestureCancelCallback =+    Gdk.EventSequence ->+    IO ()++noGestureCancelCallback :: Maybe GestureCancelCallback+noGestureCancelCallback = Nothing++type GestureCancelCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventSequence ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureCancelCallback :: GestureCancelCallbackC -> IO (FunPtr GestureCancelCallbackC)++gestureCancelClosure :: GestureCancelCallback -> IO Closure+gestureCancelClosure cb = newCClosure =<< mkGestureCancelCallback wrapped+    where wrapped = gestureCancelCallbackWrapper cb++gestureCancelCallbackWrapper ::+    GestureCancelCallback ->+    Ptr () ->+    Ptr Gdk.EventSequence ->+    Ptr () ->+    IO ()+gestureCancelCallbackWrapper _cb _ sequence _ = do+    sequence' <- (newBoxed Gdk.EventSequence) sequence+    _cb  sequence'++onGestureCancel :: (GObject a, MonadIO m) => a -> GestureCancelCallback -> m SignalHandlerId+onGestureCancel obj cb = liftIO $ connectGestureCancel obj cb SignalConnectBefore+afterGestureCancel :: (GObject a, MonadIO m) => a -> GestureCancelCallback -> m SignalHandlerId+afterGestureCancel obj cb = connectGestureCancel obj cb SignalConnectAfter++connectGestureCancel :: (GObject a, MonadIO m) =>+                        a -> GestureCancelCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureCancel obj cb after = liftIO $ do+    cb' <- mkGestureCancelCallback (gestureCancelCallbackWrapper cb)+    connectSignalFunPtr obj "cancel" cb' after++-- signal Gesture::end+type GestureEndCallback =+    Gdk.EventSequence ->+    IO ()++noGestureEndCallback :: Maybe GestureEndCallback+noGestureEndCallback = Nothing++type GestureEndCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventSequence ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureEndCallback :: GestureEndCallbackC -> IO (FunPtr GestureEndCallbackC)++gestureEndClosure :: GestureEndCallback -> IO Closure+gestureEndClosure cb = newCClosure =<< mkGestureEndCallback wrapped+    where wrapped = gestureEndCallbackWrapper cb++gestureEndCallbackWrapper ::+    GestureEndCallback ->+    Ptr () ->+    Ptr Gdk.EventSequence ->+    Ptr () ->+    IO ()+gestureEndCallbackWrapper _cb _ sequence _ = do+    sequence' <- (newBoxed Gdk.EventSequence) sequence+    _cb  sequence'++onGestureEnd :: (GObject a, MonadIO m) => a -> GestureEndCallback -> m SignalHandlerId+onGestureEnd obj cb = liftIO $ connectGestureEnd obj cb SignalConnectBefore+afterGestureEnd :: (GObject a, MonadIO m) => a -> GestureEndCallback -> m SignalHandlerId+afterGestureEnd obj cb = connectGestureEnd obj cb SignalConnectAfter++connectGestureEnd :: (GObject a, MonadIO m) =>+                     a -> GestureEndCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureEnd obj cb after = liftIO $ do+    cb' <- mkGestureEndCallback (gestureEndCallbackWrapper cb)+    connectSignalFunPtr obj "end" cb' after++-- signal Gesture::sequence-state-changed+type GestureSequenceStateChangedCallback =+    Gdk.EventSequence ->+    EventSequenceState ->+    IO ()++noGestureSequenceStateChangedCallback :: Maybe GestureSequenceStateChangedCallback+noGestureSequenceStateChangedCallback = Nothing++type GestureSequenceStateChangedCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventSequence ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureSequenceStateChangedCallback :: GestureSequenceStateChangedCallbackC -> IO (FunPtr GestureSequenceStateChangedCallbackC)++gestureSequenceStateChangedClosure :: GestureSequenceStateChangedCallback -> IO Closure+gestureSequenceStateChangedClosure cb = newCClosure =<< mkGestureSequenceStateChangedCallback wrapped+    where wrapped = gestureSequenceStateChangedCallbackWrapper cb++gestureSequenceStateChangedCallbackWrapper ::+    GestureSequenceStateChangedCallback ->+    Ptr () ->+    Ptr Gdk.EventSequence ->+    CUInt ->+    Ptr () ->+    IO ()+gestureSequenceStateChangedCallbackWrapper _cb _ sequence state _ = do+    sequence' <- (newBoxed Gdk.EventSequence) sequence+    let state' = (toEnum . fromIntegral) state+    _cb  sequence' state'++onGestureSequenceStateChanged :: (GObject a, MonadIO m) => a -> GestureSequenceStateChangedCallback -> m SignalHandlerId+onGestureSequenceStateChanged obj cb = liftIO $ connectGestureSequenceStateChanged obj cb SignalConnectBefore+afterGestureSequenceStateChanged :: (GObject a, MonadIO m) => a -> GestureSequenceStateChangedCallback -> m SignalHandlerId+afterGestureSequenceStateChanged obj cb = connectGestureSequenceStateChanged obj cb SignalConnectAfter++connectGestureSequenceStateChanged :: (GObject a, MonadIO m) =>+                                      a -> GestureSequenceStateChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureSequenceStateChanged obj cb after = liftIO $ do+    cb' <- mkGestureSequenceStateChangedCallback (gestureSequenceStateChangedCallbackWrapper cb)+    connectSignalFunPtr obj "sequence-state-changed" cb' after++-- signal Gesture::update+type GestureUpdateCallback =+    Gdk.EventSequence ->+    IO ()++noGestureUpdateCallback :: Maybe GestureUpdateCallback+noGestureUpdateCallback = Nothing++type GestureUpdateCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.EventSequence ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureUpdateCallback :: GestureUpdateCallbackC -> IO (FunPtr GestureUpdateCallbackC)++gestureUpdateClosure :: GestureUpdateCallback -> IO Closure+gestureUpdateClosure cb = newCClosure =<< mkGestureUpdateCallback wrapped+    where wrapped = gestureUpdateCallbackWrapper cb++gestureUpdateCallbackWrapper ::+    GestureUpdateCallback ->+    Ptr () ->+    Ptr Gdk.EventSequence ->+    Ptr () ->+    IO ()+gestureUpdateCallbackWrapper _cb _ sequence _ = do+    sequence' <- (newBoxed Gdk.EventSequence) sequence+    _cb  sequence'++onGestureUpdate :: (GObject a, MonadIO m) => a -> GestureUpdateCallback -> m SignalHandlerId+onGestureUpdate obj cb = liftIO $ connectGestureUpdate obj cb SignalConnectBefore+afterGestureUpdate :: (GObject a, MonadIO m) => a -> GestureUpdateCallback -> m SignalHandlerId+afterGestureUpdate obj cb = connectGestureUpdate obj cb SignalConnectAfter++connectGestureUpdate :: (GObject a, MonadIO m) =>+                        a -> GestureUpdateCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureUpdate obj cb after = liftIO $ do+    cb' <- mkGestureUpdateCallback (gestureUpdateCallbackWrapper cb)+    connectSignalFunPtr obj "update" cb' after++-- VVV Prop "n-points"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getGestureNPoints :: (MonadIO m, GestureK o) => o -> m Word32+getGestureNPoints obj = liftIO $ getObjectPropertyCUInt obj "n-points"++constructGestureNPoints :: Word32 -> IO ([Char], GValue)+constructGestureNPoints val = constructObjectPropertyCUInt "n-points" val++data GestureNPointsPropertyInfo+instance AttrInfo GestureNPointsPropertyInfo where+    type AttrAllowedOps GestureNPointsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureNPointsPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint GestureNPointsPropertyInfo = GestureK+    type AttrGetType GestureNPointsPropertyInfo = Word32+    type AttrLabel GestureNPointsPropertyInfo = "Gesture::n-points"+    attrGet _ = getGestureNPoints+    attrSet _ = undefined+    attrConstruct _ = constructGestureNPoints++-- VVV Prop "window"+   -- Type: TInterface "Gdk" "Window"+   -- Flags: [PropertyReadable,PropertyWritable]++getGestureWindow :: (MonadIO m, GestureK o) => o -> m Gdk.Window+getGestureWindow obj = liftIO $ getObjectPropertyObject obj "window" Gdk.Window++setGestureWindow :: (MonadIO m, GestureK o, Gdk.WindowK a) => o -> a -> m ()+setGestureWindow obj val = liftIO $ setObjectPropertyObject obj "window" val++constructGestureWindow :: (Gdk.WindowK a) => a -> IO ([Char], GValue)+constructGestureWindow val = constructObjectPropertyObject "window" val++data GestureWindowPropertyInfo+instance AttrInfo GestureWindowPropertyInfo where+    type AttrAllowedOps GestureWindowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureWindowPropertyInfo = Gdk.WindowK+    type AttrBaseTypeConstraint GestureWindowPropertyInfo = GestureK+    type AttrGetType GestureWindowPropertyInfo = Gdk.Window+    type AttrLabel GestureWindowPropertyInfo = "Gesture::window"+    attrGet _ = getGestureWindow+    attrSet _ = setGestureWindow+    attrConstruct _ = constructGestureWindow++type instance AttributeList Gesture = GestureAttributeList+type GestureAttributeList = ('[ '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureBeginSignalInfo+instance SignalInfo GestureBeginSignalInfo where+    type HaskellCallbackType GestureBeginSignalInfo = GestureBeginCallback+    connectSignal _ = connectGestureBegin++data GestureCancelSignalInfo+instance SignalInfo GestureCancelSignalInfo where+    type HaskellCallbackType GestureCancelSignalInfo = GestureCancelCallback+    connectSignal _ = connectGestureCancel++data GestureEndSignalInfo+instance SignalInfo GestureEndSignalInfo where+    type HaskellCallbackType GestureEndSignalInfo = GestureEndCallback+    connectSignal _ = connectGestureEnd++data GestureSequenceStateChangedSignalInfo+instance SignalInfo GestureSequenceStateChangedSignalInfo where+    type HaskellCallbackType GestureSequenceStateChangedSignalInfo = GestureSequenceStateChangedCallback+    connectSignal _ = connectGestureSequenceStateChanged++data GestureUpdateSignalInfo+instance SignalInfo GestureUpdateSignalInfo where+    type HaskellCallbackType GestureUpdateSignalInfo = GestureUpdateCallback+    connectSignal _ = connectGestureUpdate++type instance SignalList Gesture = GestureSignalList+type GestureSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Gesture::get_bounding_box+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_bounding_box" gtk_gesture_get_bounding_box :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO CInt+++gestureGetBoundingBox ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m (Bool,Gdk.Rectangle)+gestureGetBoundingBox _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_gesture_get_bounding_box _obj' rect+    let result' = (/= 0) result+    rect' <- (wrapBoxed Gdk.Rectangle) rect+    touchManagedPtr _obj+    return (result', rect')++-- method Gesture::get_bounding_box_center+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_bounding_box_center" gtk_gesture_get_bounding_box_center :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr CDouble ->                          -- x : TBasicType TDouble+    Ptr CDouble ->                          -- y : TBasicType TDouble+    IO CInt+++gestureGetBoundingBoxCenter ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m (Bool,Double,Double)+gestureGetBoundingBoxCenter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    x <- allocMem :: IO (Ptr CDouble)+    y <- allocMem :: IO (Ptr CDouble)+    result <- gtk_gesture_get_bounding_box_center _obj' x y+    let result' = (/= 0) result+    x' <- peek x+    let x'' = realToFrac x'+    y' <- peek y+    let y'' = realToFrac y'+    touchManagedPtr _obj+    freeMem x+    freeMem y+    return (result', x'', y'')++-- method Gesture::get_device+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Device"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_device" gtk_gesture_get_device :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO (Ptr Gdk.Device)+++gestureGetDevice ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m Gdk.Device+gestureGetDevice _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_get_device _obj'+    checkUnexpectedReturnNULL "gtk_gesture_get_device" result+    result' <- (newObject Gdk.Device) result+    touchManagedPtr _obj+    return result'++-- method Gesture::get_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "Gesture")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_group" gtk_gesture_get_group :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO (Ptr (GList (Ptr Gesture)))+++gestureGetGroup ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m [Gesture]+gestureGetGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_get_group _obj'+    checkUnexpectedReturnNULL "gtk_gesture_get_group" result+    result' <- unpackGList result+    result'' <- mapM (newObject Gesture) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Gesture::get_last_event+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_last_event" gtk_gesture_get_last_event :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.EventSequence ->                -- sequence : TInterface "Gdk" "EventSequence"+    IO (Ptr Gdk.Event)+++gestureGetLastEvent ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    Gdk.EventSequence ->                    -- sequence+    m Gdk.Event+gestureGetLastEvent _obj sequence = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sequence' = unsafeManagedPtrGetPtr sequence+    result <- gtk_gesture_get_last_event _obj' sequence'+    checkUnexpectedReturnNULL "gtk_gesture_get_last_event" result+    result' <- (newBoxed Gdk.Event) result+    touchManagedPtr _obj+    touchManagedPtr sequence+    return result'++-- method Gesture::get_last_updated_sequence+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "EventSequence"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_last_updated_sequence" gtk_gesture_get_last_updated_sequence :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO (Ptr Gdk.EventSequence)+++gestureGetLastUpdatedSequence ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m Gdk.EventSequence+gestureGetLastUpdatedSequence _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_get_last_updated_sequence _obj'+    checkUnexpectedReturnNULL "gtk_gesture_get_last_updated_sequence" result+    result' <- (wrapBoxed Gdk.EventSequence) result+    touchManagedPtr _obj+    return result'++-- method Gesture::get_point+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_point" gtk_gesture_get_point :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.EventSequence ->                -- sequence : TInterface "Gdk" "EventSequence"+    Ptr CDouble ->                          -- x : TBasicType TDouble+    Ptr CDouble ->                          -- y : TBasicType TDouble+    IO CInt+++gestureGetPoint ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    Maybe (Gdk.EventSequence) ->            -- sequence+    m (Bool,Double,Double)+gestureGetPoint _obj sequence = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSequence <- case sequence of+        Nothing -> return nullPtr+        Just jSequence -> do+            let jSequence' = unsafeManagedPtrGetPtr jSequence+            return jSequence'+    x <- allocMem :: IO (Ptr CDouble)+    y <- allocMem :: IO (Ptr CDouble)+    result <- gtk_gesture_get_point _obj' maybeSequence x y+    let result' = (/= 0) result+    x' <- peek x+    let x'' = realToFrac x'+    y' <- peek y+    let y'' = realToFrac y'+    touchManagedPtr _obj+    whenJust sequence touchManagedPtr+    freeMem x+    freeMem y+    return (result', x'', y'')++-- method Gesture::get_sequence_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "EventSequenceState"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_sequence_state" gtk_gesture_get_sequence_state :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.EventSequence ->                -- sequence : TInterface "Gdk" "EventSequence"+    IO CUInt+++gestureGetSequenceState ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    Gdk.EventSequence ->                    -- sequence+    m EventSequenceState+gestureGetSequenceState _obj sequence = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sequence' = unsafeManagedPtrGetPtr sequence+    result <- gtk_gesture_get_sequence_state _obj' sequence'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr sequence+    return result'++-- method Gesture::get_sequences+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gdk" "EventSequence")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_sequences" gtk_gesture_get_sequences :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO (Ptr (GList (Ptr Gdk.EventSequence)))+++gestureGetSequences ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m [Gdk.EventSequence]+gestureGetSequences _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_get_sequences _obj'+    checkUnexpectedReturnNULL "gtk_gesture_get_sequences" result+    result' <- unpackGList result+    result'' <- mapM (newBoxed Gdk.EventSequence) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Gesture::get_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_get_window" gtk_gesture_get_window :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO (Ptr Gdk.Window)+++gestureGetWindow ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m Gdk.Window+gestureGetWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_get_window _obj'+    checkUnexpectedReturnNULL "gtk_gesture_get_window" result+    result' <- (newObject Gdk.Window) result+    touchManagedPtr _obj+    return result'++-- method Gesture::group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gesture", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gesture", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_group" gtk_gesture_group :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gesture ->                          -- gesture : TInterface "Gtk" "Gesture"+    IO ()+++gestureGroup ::+    (MonadIO m, GestureK a, GestureK b) =>+    a ->                                    -- _obj+    b ->                                    -- gesture+    m ()+gestureGroup _obj gesture = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let gesture' = unsafeManagedPtrCastPtr gesture+    gtk_gesture_group _obj' gesture'+    touchManagedPtr _obj+    touchManagedPtr gesture+    return ()++-- method Gesture::handles_sequence+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_handles_sequence" gtk_gesture_handles_sequence :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.EventSequence ->                -- sequence : TInterface "Gdk" "EventSequence"+    IO CInt+++gestureHandlesSequence ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    Gdk.EventSequence ->                    -- sequence+    m Bool+gestureHandlesSequence _obj sequence = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sequence' = unsafeManagedPtrGetPtr sequence+    result <- gtk_gesture_handles_sequence _obj' sequence'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr sequence+    return result'++-- method Gesture::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_is_active" gtk_gesture_is_active :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO CInt+++gestureIsActive ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m Bool+gestureIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Gesture::is_grouped_with+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "other", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_is_grouped_with" gtk_gesture_is_grouped_with :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gesture ->                          -- other : TInterface "Gtk" "Gesture"+    IO CInt+++gestureIsGroupedWith ::+    (MonadIO m, GestureK a, GestureK b) =>+    a ->                                    -- _obj+    b ->                                    -- other+    m Bool+gestureIsGroupedWith _obj other = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let other' = unsafeManagedPtrCastPtr other+    result <- gtk_gesture_is_grouped_with _obj' other'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr other+    return result'++-- method Gesture::is_recognized+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_is_recognized" gtk_gesture_is_recognized :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO CInt+++gestureIsRecognized ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m Bool+gestureIsRecognized _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_is_recognized _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Gesture::set_sequence_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "EventSequenceState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sequence", argType = TInterface "Gdk" "EventSequence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "EventSequenceState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_set_sequence_state" gtk_gesture_set_sequence_state :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.EventSequence ->                -- sequence : TInterface "Gdk" "EventSequence"+    CUInt ->                                -- state : TInterface "Gtk" "EventSequenceState"+    IO CInt+++gestureSetSequenceState ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    Gdk.EventSequence ->                    -- sequence+    EventSequenceState ->                   -- state+    m Bool+gestureSetSequenceState _obj sequence state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sequence' = unsafeManagedPtrGetPtr sequence+    let state' = (fromIntegral . fromEnum) state+    result <- gtk_gesture_set_sequence_state _obj' sequence' state'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr sequence+    return result'++-- method Gesture::set_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "EventSequenceState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "EventSequenceState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_set_state" gtk_gesture_set_state :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    CUInt ->                                -- state : TInterface "Gtk" "EventSequenceState"+    IO CInt+++gestureSetState ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    EventSequenceState ->                   -- state+    m Bool+gestureSetState _obj state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let state' = (fromIntegral . fromEnum) state+    result <- gtk_gesture_set_state _obj' state'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Gesture::set_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_set_window" gtk_gesture_set_window :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    Ptr Gdk.Window ->                       -- window : TInterface "Gdk" "Window"+    IO ()+++gestureSetWindow ::+    (MonadIO m, GestureK a, Gdk.WindowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- window+    m ()+gestureSetWindow _obj window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWindow <- case window of+        Nothing -> return nullPtr+        Just jWindow -> do+            let jWindow' = unsafeManagedPtrCastPtr jWindow+            return jWindow'+    gtk_gesture_set_window _obj' maybeWindow+    touchManagedPtr _obj+    whenJust window touchManagedPtr+    return ()++-- method Gesture::ungroup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Gesture", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_ungroup" gtk_gesture_ungroup :: +    Ptr Gesture ->                          -- _obj : TInterface "Gtk" "Gesture"+    IO ()+++gestureUngroup ::+    (MonadIO m, GestureK a) =>+    a ->                                    -- _obj+    m ()+gestureUngroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gesture_ungroup _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Gesture.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gtk.Objects.Gesture where++import Prelude ()+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 Gesture = Gesture (ForeignPtr Gesture)+instance GObject Gesture where+class GObject o => GestureK o+instance (GObject o, IsDescendantOf Gesture o) => GestureK o+data GestureNPointsPropertyInfo+data GestureWindowPropertyInfo+data GestureBeginSignalInfo+data GestureCancelSignalInfo+data GestureEndSignalInfo+data GestureSequenceStateChangedSignalInfo+data GestureUpdateSignalInfo
+ GI/Gtk/Objects/GestureDrag.hs view
@@ -0,0 +1,287 @@++{- |+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.Gtk.Objects.GestureDrag+    ( ++-- * Exported types+    GestureDrag(..)                         ,+    GestureDragK                            ,+    toGestureDrag                           ,+    noGestureDrag                           ,+++ -- * Methods+-- ** gestureDragNew+    gestureDragNew                          ,+++++ -- * Signals+-- ** DragBegin+    GestureDragDragBeginCallback            ,+    GestureDragDragBeginCallbackC           ,+    GestureDragDragBeginSignalInfo          ,+    afterGestureDragDragBegin               ,+    gestureDragDragBeginCallbackWrapper     ,+    gestureDragDragBeginClosure             ,+    mkGestureDragDragBeginCallback          ,+    noGestureDragDragBeginCallback          ,+    onGestureDragDragBegin                  ,+++-- ** DragEnd+    GestureDragDragEndCallback              ,+    GestureDragDragEndCallbackC             ,+    GestureDragDragEndSignalInfo            ,+    afterGestureDragDragEnd                 ,+    gestureDragDragEndCallbackWrapper       ,+    gestureDragDragEndClosure               ,+    mkGestureDragDragEndCallback            ,+    noGestureDragDragEndCallback            ,+    onGestureDragDragEnd                    ,+++-- ** DragUpdate+    GestureDragDragUpdateCallback           ,+    GestureDragDragUpdateCallbackC          ,+    GestureDragDragUpdateSignalInfo         ,+    afterGestureDragDragUpdate              ,+    gestureDragDragUpdateCallbackWrapper    ,+    gestureDragDragUpdateClosure            ,+    mkGestureDragDragUpdateCallback         ,+    noGestureDragDragUpdateCallback         ,+    onGestureDragDragUpdate                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GestureDrag = GestureDrag (ForeignPtr GestureDrag)+foreign import ccall "gtk_gesture_drag_get_type"+    c_gtk_gesture_drag_get_type :: IO GType++type instance ParentTypes GestureDrag = GestureDragParentTypes+type GestureDragParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]++instance GObject GestureDrag where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_drag_get_type+    ++class GObject o => GestureDragK o+instance (GObject o, IsDescendantOf GestureDrag o) => GestureDragK o++toGestureDrag :: GestureDragK o => o -> IO GestureDrag+toGestureDrag = unsafeCastTo GestureDrag++noGestureDrag :: Maybe GestureDrag+noGestureDrag = Nothing++-- signal GestureDrag::drag-begin+type GestureDragDragBeginCallback =+    Double ->+    Double ->+    IO ()++noGestureDragDragBeginCallback :: Maybe GestureDragDragBeginCallback+noGestureDragDragBeginCallback = Nothing++type GestureDragDragBeginCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureDragDragBeginCallback :: GestureDragDragBeginCallbackC -> IO (FunPtr GestureDragDragBeginCallbackC)++gestureDragDragBeginClosure :: GestureDragDragBeginCallback -> IO Closure+gestureDragDragBeginClosure cb = newCClosure =<< mkGestureDragDragBeginCallback wrapped+    where wrapped = gestureDragDragBeginCallbackWrapper cb++gestureDragDragBeginCallbackWrapper ::+    GestureDragDragBeginCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureDragDragBeginCallbackWrapper _cb _ start_x start_y _ = do+    let start_x' = realToFrac start_x+    let start_y' = realToFrac start_y+    _cb  start_x' start_y'++onGestureDragDragBegin :: (GObject a, MonadIO m) => a -> GestureDragDragBeginCallback -> m SignalHandlerId+onGestureDragDragBegin obj cb = liftIO $ connectGestureDragDragBegin obj cb SignalConnectBefore+afterGestureDragDragBegin :: (GObject a, MonadIO m) => a -> GestureDragDragBeginCallback -> m SignalHandlerId+afterGestureDragDragBegin obj cb = connectGestureDragDragBegin obj cb SignalConnectAfter++connectGestureDragDragBegin :: (GObject a, MonadIO m) =>+                               a -> GestureDragDragBeginCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureDragDragBegin obj cb after = liftIO $ do+    cb' <- mkGestureDragDragBeginCallback (gestureDragDragBeginCallbackWrapper cb)+    connectSignalFunPtr obj "drag-begin" cb' after++-- signal GestureDrag::drag-end+type GestureDragDragEndCallback =+    Double ->+    Double ->+    IO ()++noGestureDragDragEndCallback :: Maybe GestureDragDragEndCallback+noGestureDragDragEndCallback = Nothing++type GestureDragDragEndCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureDragDragEndCallback :: GestureDragDragEndCallbackC -> IO (FunPtr GestureDragDragEndCallbackC)++gestureDragDragEndClosure :: GestureDragDragEndCallback -> IO Closure+gestureDragDragEndClosure cb = newCClosure =<< mkGestureDragDragEndCallback wrapped+    where wrapped = gestureDragDragEndCallbackWrapper cb++gestureDragDragEndCallbackWrapper ::+    GestureDragDragEndCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureDragDragEndCallbackWrapper _cb _ offset_x offset_y _ = do+    let offset_x' = realToFrac offset_x+    let offset_y' = realToFrac offset_y+    _cb  offset_x' offset_y'++onGestureDragDragEnd :: (GObject a, MonadIO m) => a -> GestureDragDragEndCallback -> m SignalHandlerId+onGestureDragDragEnd obj cb = liftIO $ connectGestureDragDragEnd obj cb SignalConnectBefore+afterGestureDragDragEnd :: (GObject a, MonadIO m) => a -> GestureDragDragEndCallback -> m SignalHandlerId+afterGestureDragDragEnd obj cb = connectGestureDragDragEnd obj cb SignalConnectAfter++connectGestureDragDragEnd :: (GObject a, MonadIO m) =>+                             a -> GestureDragDragEndCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureDragDragEnd obj cb after = liftIO $ do+    cb' <- mkGestureDragDragEndCallback (gestureDragDragEndCallbackWrapper cb)+    connectSignalFunPtr obj "drag-end" cb' after++-- signal GestureDrag::drag-update+type GestureDragDragUpdateCallback =+    Double ->+    Double ->+    IO ()++noGestureDragDragUpdateCallback :: Maybe GestureDragDragUpdateCallback+noGestureDragDragUpdateCallback = Nothing++type GestureDragDragUpdateCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureDragDragUpdateCallback :: GestureDragDragUpdateCallbackC -> IO (FunPtr GestureDragDragUpdateCallbackC)++gestureDragDragUpdateClosure :: GestureDragDragUpdateCallback -> IO Closure+gestureDragDragUpdateClosure cb = newCClosure =<< mkGestureDragDragUpdateCallback wrapped+    where wrapped = gestureDragDragUpdateCallbackWrapper cb++gestureDragDragUpdateCallbackWrapper ::+    GestureDragDragUpdateCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureDragDragUpdateCallbackWrapper _cb _ offset_x offset_y _ = do+    let offset_x' = realToFrac offset_x+    let offset_y' = realToFrac offset_y+    _cb  offset_x' offset_y'++onGestureDragDragUpdate :: (GObject a, MonadIO m) => a -> GestureDragDragUpdateCallback -> m SignalHandlerId+onGestureDragDragUpdate obj cb = liftIO $ connectGestureDragDragUpdate obj cb SignalConnectBefore+afterGestureDragDragUpdate :: (GObject a, MonadIO m) => a -> GestureDragDragUpdateCallback -> m SignalHandlerId+afterGestureDragDragUpdate obj cb = connectGestureDragDragUpdate obj cb SignalConnectAfter++connectGestureDragDragUpdate :: (GObject a, MonadIO m) =>+                                a -> GestureDragDragUpdateCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureDragDragUpdate obj cb after = liftIO $ do+    cb' <- mkGestureDragDragUpdateCallback (gestureDragDragUpdateCallbackWrapper cb)+    connectSignalFunPtr obj "drag-update" cb' after++type instance AttributeList GestureDrag = GestureDragAttributeList+type GestureDragAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureDragDragBeginSignalInfo+instance SignalInfo GestureDragDragBeginSignalInfo where+    type HaskellCallbackType GestureDragDragBeginSignalInfo = GestureDragDragBeginCallback+    connectSignal _ = connectGestureDragDragBegin++data GestureDragDragEndSignalInfo+instance SignalInfo GestureDragDragEndSignalInfo where+    type HaskellCallbackType GestureDragDragEndSignalInfo = GestureDragDragEndCallback+    connectSignal _ = connectGestureDragDragEnd++data GestureDragDragUpdateSignalInfo+instance SignalInfo GestureDragDragUpdateSignalInfo where+    type HaskellCallbackType GestureDragDragUpdateSignalInfo = GestureDragDragUpdateCallback+    connectSignal _ = connectGestureDragDragUpdate++type instance SignalList GestureDrag = GestureDragSignalList+type GestureDragSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("drag-begin", GestureDragDragBeginSignalInfo), '("drag-end", GestureDragDragEndSignalInfo), '("drag-update", GestureDragDragUpdateSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureDrag::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureDrag"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_drag_new" gtk_gesture_drag_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureDrag)+++gestureDragNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureDrag+gestureDragNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_drag_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_drag_new" result+    result' <- (wrapObject GestureDrag) result+    touchManagedPtr widget+    return result'++-- XXX Could not generate method GestureDrag::get_offset+-- Error was : Bad introspection data: "argument \"x\" is not of nullable type (TBasicType TDouble), but it is marked as such."+-- XXX Could not generate method GestureDrag::get_start_point+-- Error was : Bad introspection data: "argument \"x\" is not of nullable type (TBasicType TDouble), but it is marked as such."+
+ GI/Gtk/Objects/GestureDrag.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.GestureDrag where++import Prelude ()+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 GestureDrag = GestureDrag (ForeignPtr GestureDrag)+instance GObject GestureDrag where+class GObject o => GestureDragK o+instance (GObject o, IsDescendantOf GestureDrag o) => GestureDragK o+data GestureDragDragBeginSignalInfo+data GestureDragDragEndSignalInfo+data GestureDragDragUpdateSignalInfo
+ GI/Gtk/Objects/GestureLongPress.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.Gtk.Objects.GestureLongPress+    ( ++-- * Exported types+    GestureLongPress(..)                    ,+    GestureLongPressK                       ,+    toGestureLongPress                      ,+    noGestureLongPress                      ,+++ -- * Methods+-- ** gestureLongPressNew+    gestureLongPressNew                     ,+++++ -- * Properties+-- ** DelayFactor+    GestureLongPressDelayFactorPropertyInfo ,+    constructGestureLongPressDelayFactor    ,+    getGestureLongPressDelayFactor          ,+    setGestureLongPressDelayFactor          ,+++++ -- * Signals+-- ** Cancelled+    GestureLongPressCancelledCallback       ,+    GestureLongPressCancelledCallbackC      ,+    GestureLongPressCancelledSignalInfo     ,+    afterGestureLongPressCancelled          ,+    gestureLongPressCancelledCallbackWrapper,+    gestureLongPressCancelledClosure        ,+    mkGestureLongPressCancelledCallback     ,+    noGestureLongPressCancelledCallback     ,+    onGestureLongPressCancelled             ,+++-- ** Pressed+    GestureLongPressPressedCallback         ,+    GestureLongPressPressedCallbackC        ,+    GestureLongPressPressedSignalInfo       ,+    afterGestureLongPressPressed            ,+    gestureLongPressPressedCallbackWrapper  ,+    gestureLongPressPressedClosure          ,+    mkGestureLongPressPressedCallback       ,+    noGestureLongPressPressedCallback       ,+    onGestureLongPressPressed               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GestureLongPress = GestureLongPress (ForeignPtr GestureLongPress)+foreign import ccall "gtk_gesture_long_press_get_type"+    c_gtk_gesture_long_press_get_type :: IO GType++type instance ParentTypes GestureLongPress = GestureLongPressParentTypes+type GestureLongPressParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]++instance GObject GestureLongPress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_long_press_get_type+    ++class GObject o => GestureLongPressK o+instance (GObject o, IsDescendantOf GestureLongPress o) => GestureLongPressK o++toGestureLongPress :: GestureLongPressK o => o -> IO GestureLongPress+toGestureLongPress = unsafeCastTo GestureLongPress++noGestureLongPress :: Maybe GestureLongPress+noGestureLongPress = Nothing++-- signal GestureLongPress::cancelled+type GestureLongPressCancelledCallback =+    IO ()++noGestureLongPressCancelledCallback :: Maybe GestureLongPressCancelledCallback+noGestureLongPressCancelledCallback = Nothing++type GestureLongPressCancelledCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureLongPressCancelledCallback :: GestureLongPressCancelledCallbackC -> IO (FunPtr GestureLongPressCancelledCallbackC)++gestureLongPressCancelledClosure :: GestureLongPressCancelledCallback -> IO Closure+gestureLongPressCancelledClosure cb = newCClosure =<< mkGestureLongPressCancelledCallback wrapped+    where wrapped = gestureLongPressCancelledCallbackWrapper cb++gestureLongPressCancelledCallbackWrapper ::+    GestureLongPressCancelledCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+gestureLongPressCancelledCallbackWrapper _cb _ _ = do+    _cb ++onGestureLongPressCancelled :: (GObject a, MonadIO m) => a -> GestureLongPressCancelledCallback -> m SignalHandlerId+onGestureLongPressCancelled obj cb = liftIO $ connectGestureLongPressCancelled obj cb SignalConnectBefore+afterGestureLongPressCancelled :: (GObject a, MonadIO m) => a -> GestureLongPressCancelledCallback -> m SignalHandlerId+afterGestureLongPressCancelled obj cb = connectGestureLongPressCancelled obj cb SignalConnectAfter++connectGestureLongPressCancelled :: (GObject a, MonadIO m) =>+                                    a -> GestureLongPressCancelledCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureLongPressCancelled obj cb after = liftIO $ do+    cb' <- mkGestureLongPressCancelledCallback (gestureLongPressCancelledCallbackWrapper cb)+    connectSignalFunPtr obj "cancelled" cb' after++-- signal GestureLongPress::pressed+type GestureLongPressPressedCallback =+    Double ->+    Double ->+    IO ()++noGestureLongPressPressedCallback :: Maybe GestureLongPressPressedCallback+noGestureLongPressPressedCallback = Nothing++type GestureLongPressPressedCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureLongPressPressedCallback :: GestureLongPressPressedCallbackC -> IO (FunPtr GestureLongPressPressedCallbackC)++gestureLongPressPressedClosure :: GestureLongPressPressedCallback -> IO Closure+gestureLongPressPressedClosure cb = newCClosure =<< mkGestureLongPressPressedCallback wrapped+    where wrapped = gestureLongPressPressedCallbackWrapper cb++gestureLongPressPressedCallbackWrapper ::+    GestureLongPressPressedCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureLongPressPressedCallbackWrapper _cb _ x y _ = do+    let x' = realToFrac x+    let y' = realToFrac y+    _cb  x' y'++onGestureLongPressPressed :: (GObject a, MonadIO m) => a -> GestureLongPressPressedCallback -> m SignalHandlerId+onGestureLongPressPressed obj cb = liftIO $ connectGestureLongPressPressed obj cb SignalConnectBefore+afterGestureLongPressPressed :: (GObject a, MonadIO m) => a -> GestureLongPressPressedCallback -> m SignalHandlerId+afterGestureLongPressPressed obj cb = connectGestureLongPressPressed obj cb SignalConnectAfter++connectGestureLongPressPressed :: (GObject a, MonadIO m) =>+                                  a -> GestureLongPressPressedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureLongPressPressed obj cb after = liftIO $ do+    cb' <- mkGestureLongPressPressedCallback (gestureLongPressPressedCallbackWrapper cb)+    connectSignalFunPtr obj "pressed" cb' after++-- VVV Prop "delay-factor"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getGestureLongPressDelayFactor :: (MonadIO m, GestureLongPressK o) => o -> m Double+getGestureLongPressDelayFactor obj = liftIO $ getObjectPropertyDouble obj "delay-factor"++setGestureLongPressDelayFactor :: (MonadIO m, GestureLongPressK o) => o -> Double -> m ()+setGestureLongPressDelayFactor obj val = liftIO $ setObjectPropertyDouble obj "delay-factor" val++constructGestureLongPressDelayFactor :: Double -> IO ([Char], GValue)+constructGestureLongPressDelayFactor val = constructObjectPropertyDouble "delay-factor" val++data GestureLongPressDelayFactorPropertyInfo+instance AttrInfo GestureLongPressDelayFactorPropertyInfo where+    type AttrAllowedOps GestureLongPressDelayFactorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureLongPressDelayFactorPropertyInfo = (~) Double+    type AttrBaseTypeConstraint GestureLongPressDelayFactorPropertyInfo = GestureLongPressK+    type AttrGetType GestureLongPressDelayFactorPropertyInfo = Double+    type AttrLabel GestureLongPressDelayFactorPropertyInfo = "GestureLongPress::delay-factor"+    attrGet _ = getGestureLongPressDelayFactor+    attrSet _ = setGestureLongPressDelayFactor+    attrConstruct _ = constructGestureLongPressDelayFactor++type instance AttributeList GestureLongPress = GestureLongPressAttributeList+type GestureLongPressAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("delay-factor", GestureLongPressDelayFactorPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureLongPressCancelledSignalInfo+instance SignalInfo GestureLongPressCancelledSignalInfo where+    type HaskellCallbackType GestureLongPressCancelledSignalInfo = GestureLongPressCancelledCallback+    connectSignal _ = connectGestureLongPressCancelled++data GestureLongPressPressedSignalInfo+instance SignalInfo GestureLongPressPressedSignalInfo where+    type HaskellCallbackType GestureLongPressPressedSignalInfo = GestureLongPressPressedCallback+    connectSignal _ = connectGestureLongPressPressed++type instance SignalList GestureLongPress = GestureLongPressSignalList+type GestureLongPressSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("cancelled", GestureLongPressCancelledSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pressed", GestureLongPressPressedSignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureLongPress::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureLongPress"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_long_press_new" gtk_gesture_long_press_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureLongPress)+++gestureLongPressNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureLongPress+gestureLongPressNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_long_press_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_long_press_new" result+    result' <- (wrapObject GestureLongPress) result+    touchManagedPtr widget+    return result'++
+ GI/Gtk/Objects/GestureLongPress.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.GestureLongPress where++import Prelude ()+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 GestureLongPress = GestureLongPress (ForeignPtr GestureLongPress)+instance GObject GestureLongPress where+class GObject o => GestureLongPressK o+instance (GObject o, IsDescendantOf GestureLongPress o) => GestureLongPressK o+data GestureLongPressDelayFactorPropertyInfo+data GestureLongPressCancelledSignalInfo+data GestureLongPressPressedSignalInfo
+ GI/Gtk/Objects/GestureMultiPress.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.Gtk.Objects.GestureMultiPress+    ( ++-- * Exported types+    GestureMultiPress(..)                   ,+    GestureMultiPressK                      ,+    toGestureMultiPress                     ,+    noGestureMultiPress                     ,+++ -- * Methods+-- ** gestureMultiPressGetArea+    gestureMultiPressGetArea                ,+++-- ** gestureMultiPressNew+    gestureMultiPressNew                    ,+++-- ** gestureMultiPressSetArea+    gestureMultiPressSetArea                ,+++++ -- * Signals+-- ** Pressed+    GestureMultiPressPressedCallback        ,+    GestureMultiPressPressedCallbackC       ,+    GestureMultiPressPressedSignalInfo      ,+    afterGestureMultiPressPressed           ,+    gestureMultiPressPressedCallbackWrapper ,+    gestureMultiPressPressedClosure         ,+    mkGestureMultiPressPressedCallback      ,+    noGestureMultiPressPressedCallback      ,+    onGestureMultiPressPressed              ,+++-- ** Released+    GestureMultiPressReleasedCallback       ,+    GestureMultiPressReleasedCallbackC      ,+    GestureMultiPressReleasedSignalInfo     ,+    afterGestureMultiPressReleased          ,+    gestureMultiPressReleasedCallbackWrapper,+    gestureMultiPressReleasedClosure        ,+    mkGestureMultiPressReleasedCallback     ,+    noGestureMultiPressReleasedCallback     ,+    onGestureMultiPressReleased             ,+++-- ** Stopped+    GestureMultiPressStoppedCallback        ,+    GestureMultiPressStoppedCallbackC       ,+    GestureMultiPressStoppedSignalInfo      ,+    afterGestureMultiPressStopped           ,+    gestureMultiPressStoppedCallbackWrapper ,+    gestureMultiPressStoppedClosure         ,+    mkGestureMultiPressStoppedCallback      ,+    noGestureMultiPressStoppedCallback      ,+    onGestureMultiPressStopped              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype GestureMultiPress = GestureMultiPress (ForeignPtr GestureMultiPress)+foreign import ccall "gtk_gesture_multi_press_get_type"+    c_gtk_gesture_multi_press_get_type :: IO GType++type instance ParentTypes GestureMultiPress = GestureMultiPressParentTypes+type GestureMultiPressParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]++instance GObject GestureMultiPress where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_multi_press_get_type+    ++class GObject o => GestureMultiPressK o+instance (GObject o, IsDescendantOf GestureMultiPress o) => GestureMultiPressK o++toGestureMultiPress :: GestureMultiPressK o => o -> IO GestureMultiPress+toGestureMultiPress = unsafeCastTo GestureMultiPress++noGestureMultiPress :: Maybe GestureMultiPress+noGestureMultiPress = Nothing++-- signal GestureMultiPress::pressed+type GestureMultiPressPressedCallback =+    Int32 ->+    Double ->+    Double ->+    IO ()++noGestureMultiPressPressedCallback :: Maybe GestureMultiPressPressedCallback+noGestureMultiPressPressedCallback = Nothing++type GestureMultiPressPressedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureMultiPressPressedCallback :: GestureMultiPressPressedCallbackC -> IO (FunPtr GestureMultiPressPressedCallbackC)++gestureMultiPressPressedClosure :: GestureMultiPressPressedCallback -> IO Closure+gestureMultiPressPressedClosure cb = newCClosure =<< mkGestureMultiPressPressedCallback wrapped+    where wrapped = gestureMultiPressPressedCallbackWrapper cb++gestureMultiPressPressedCallbackWrapper ::+    GestureMultiPressPressedCallback ->+    Ptr () ->+    Int32 ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureMultiPressPressedCallbackWrapper _cb _ n_press x y _ = do+    let x' = realToFrac x+    let y' = realToFrac y+    _cb  n_press x' y'++onGestureMultiPressPressed :: (GObject a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId+onGestureMultiPressPressed obj cb = liftIO $ connectGestureMultiPressPressed obj cb SignalConnectBefore+afterGestureMultiPressPressed :: (GObject a, MonadIO m) => a -> GestureMultiPressPressedCallback -> m SignalHandlerId+afterGestureMultiPressPressed obj cb = connectGestureMultiPressPressed obj cb SignalConnectAfter++connectGestureMultiPressPressed :: (GObject a, MonadIO m) =>+                                   a -> GestureMultiPressPressedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureMultiPressPressed obj cb after = liftIO $ do+    cb' <- mkGestureMultiPressPressedCallback (gestureMultiPressPressedCallbackWrapper cb)+    connectSignalFunPtr obj "pressed" cb' after++-- signal GestureMultiPress::released+type GestureMultiPressReleasedCallback =+    Int32 ->+    Double ->+    Double ->+    IO ()++noGestureMultiPressReleasedCallback :: Maybe GestureMultiPressReleasedCallback+noGestureMultiPressReleasedCallback = Nothing++type GestureMultiPressReleasedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureMultiPressReleasedCallback :: GestureMultiPressReleasedCallbackC -> IO (FunPtr GestureMultiPressReleasedCallbackC)++gestureMultiPressReleasedClosure :: GestureMultiPressReleasedCallback -> IO Closure+gestureMultiPressReleasedClosure cb = newCClosure =<< mkGestureMultiPressReleasedCallback wrapped+    where wrapped = gestureMultiPressReleasedCallbackWrapper cb++gestureMultiPressReleasedCallbackWrapper ::+    GestureMultiPressReleasedCallback ->+    Ptr () ->+    Int32 ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureMultiPressReleasedCallbackWrapper _cb _ n_press x y _ = do+    let x' = realToFrac x+    let y' = realToFrac y+    _cb  n_press x' y'++onGestureMultiPressReleased :: (GObject a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId+onGestureMultiPressReleased obj cb = liftIO $ connectGestureMultiPressReleased obj cb SignalConnectBefore+afterGestureMultiPressReleased :: (GObject a, MonadIO m) => a -> GestureMultiPressReleasedCallback -> m SignalHandlerId+afterGestureMultiPressReleased obj cb = connectGestureMultiPressReleased obj cb SignalConnectAfter++connectGestureMultiPressReleased :: (GObject a, MonadIO m) =>+                                    a -> GestureMultiPressReleasedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureMultiPressReleased obj cb after = liftIO $ do+    cb' <- mkGestureMultiPressReleasedCallback (gestureMultiPressReleasedCallbackWrapper cb)+    connectSignalFunPtr obj "released" cb' after++-- signal GestureMultiPress::stopped+type GestureMultiPressStoppedCallback =+    IO ()++noGestureMultiPressStoppedCallback :: Maybe GestureMultiPressStoppedCallback+noGestureMultiPressStoppedCallback = Nothing++type GestureMultiPressStoppedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureMultiPressStoppedCallback :: GestureMultiPressStoppedCallbackC -> IO (FunPtr GestureMultiPressStoppedCallbackC)++gestureMultiPressStoppedClosure :: GestureMultiPressStoppedCallback -> IO Closure+gestureMultiPressStoppedClosure cb = newCClosure =<< mkGestureMultiPressStoppedCallback wrapped+    where wrapped = gestureMultiPressStoppedCallbackWrapper cb++gestureMultiPressStoppedCallbackWrapper ::+    GestureMultiPressStoppedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+gestureMultiPressStoppedCallbackWrapper _cb _ _ = do+    _cb ++onGestureMultiPressStopped :: (GObject a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId+onGestureMultiPressStopped obj cb = liftIO $ connectGestureMultiPressStopped obj cb SignalConnectBefore+afterGestureMultiPressStopped :: (GObject a, MonadIO m) => a -> GestureMultiPressStoppedCallback -> m SignalHandlerId+afterGestureMultiPressStopped obj cb = connectGestureMultiPressStopped obj cb SignalConnectAfter++connectGestureMultiPressStopped :: (GObject a, MonadIO m) =>+                                   a -> GestureMultiPressStoppedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureMultiPressStopped obj cb after = liftIO $ do+    cb' <- mkGestureMultiPressStoppedCallback (gestureMultiPressStoppedCallbackWrapper cb)+    connectSignalFunPtr obj "stopped" cb' after++type instance AttributeList GestureMultiPress = GestureMultiPressAttributeList+type GestureMultiPressAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureMultiPressPressedSignalInfo+instance SignalInfo GestureMultiPressPressedSignalInfo where+    type HaskellCallbackType GestureMultiPressPressedSignalInfo = GestureMultiPressPressedCallback+    connectSignal _ = connectGestureMultiPressPressed++data GestureMultiPressReleasedSignalInfo+instance SignalInfo GestureMultiPressReleasedSignalInfo where+    type HaskellCallbackType GestureMultiPressReleasedSignalInfo = GestureMultiPressReleasedCallback+    connectSignal _ = connectGestureMultiPressReleased++data GestureMultiPressStoppedSignalInfo+instance SignalInfo GestureMultiPressStoppedSignalInfo where+    type HaskellCallbackType GestureMultiPressStoppedSignalInfo = GestureMultiPressStoppedCallback+    connectSignal _ = connectGestureMultiPressStopped++type instance SignalList GestureMultiPress = GestureMultiPressSignalList+type GestureMultiPressSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pressed", GestureMultiPressPressedSignalInfo), '("released", GestureMultiPressReleasedSignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("stopped", GestureMultiPressStoppedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureMultiPress::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureMultiPress"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_multi_press_new" gtk_gesture_multi_press_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureMultiPress)+++gestureMultiPressNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureMultiPress+gestureMultiPressNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_multi_press_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_multi_press_new" result+    result' <- (wrapObject GestureMultiPress) result+    touchManagedPtr widget+    return result'++-- method GestureMultiPress::get_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_multi_press_get_area" gtk_gesture_multi_press_get_area :: +    Ptr GestureMultiPress ->                -- _obj : TInterface "Gtk" "GestureMultiPress"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO CInt+++gestureMultiPressGetArea ::+    (MonadIO m, GestureMultiPressK a) =>+    a ->                                    -- _obj+    m (Bool,Gdk.Rectangle)+gestureMultiPressGetArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_gesture_multi_press_get_area _obj' rect+    let result' = (/= 0) result+    rect' <- (wrapBoxed Gdk.Rectangle) rect+    touchManagedPtr _obj+    return (result', rect')++-- method GestureMultiPress::set_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureMultiPress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_multi_press_set_area" gtk_gesture_multi_press_set_area :: +    Ptr GestureMultiPress ->                -- _obj : TInterface "Gtk" "GestureMultiPress"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO ()+++gestureMultiPressSetArea ::+    (MonadIO m, GestureMultiPressK a) =>+    a ->                                    -- _obj+    Maybe (Gdk.Rectangle) ->                -- rect+    m ()+gestureMultiPressSetArea _obj rect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeRect <- case rect of+        Nothing -> return nullPtr+        Just jRect -> do+            let jRect' = unsafeManagedPtrGetPtr jRect+            return jRect'+    gtk_gesture_multi_press_set_area _obj' maybeRect+    touchManagedPtr _obj+    whenJust rect touchManagedPtr+    return ()++
+ GI/Gtk/Objects/GestureMultiPress.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.GestureMultiPress where++import Prelude ()+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 GestureMultiPress = GestureMultiPress (ForeignPtr GestureMultiPress)+instance GObject GestureMultiPress where+class GObject o => GestureMultiPressK o+instance (GObject o, IsDescendantOf GestureMultiPress o) => GestureMultiPressK o+data GestureMultiPressPressedSignalInfo+data GestureMultiPressReleasedSignalInfo+data GestureMultiPressStoppedSignalInfo
+ GI/Gtk/Objects/GesturePan.hs view
@@ -0,0 +1,254 @@++{- |+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.Gtk.Objects.GesturePan+    ( ++-- * Exported types+    GesturePan(..)                          ,+    GesturePanK                             ,+    toGesturePan                            ,+    noGesturePan                            ,+++ -- * Methods+-- ** gesturePanGetOrientation+    gesturePanGetOrientation                ,+++-- ** gesturePanNew+    gesturePanNew                           ,+++-- ** gesturePanSetOrientation+    gesturePanSetOrientation                ,+++++ -- * Properties+-- ** Orientation+    GesturePanOrientationPropertyInfo       ,+    constructGesturePanOrientation          ,+    getGesturePanOrientation                ,+    setGesturePanOrientation                ,+++++ -- * Signals+-- ** Pan+    GesturePanPanCallback                   ,+    GesturePanPanCallbackC                  ,+    GesturePanPanSignalInfo                 ,+    afterGesturePanPan                      ,+    gesturePanPanCallbackWrapper            ,+    gesturePanPanClosure                    ,+    mkGesturePanPanCallback                 ,+    noGesturePanPanCallback                 ,+    onGesturePanPan                         ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GesturePan = GesturePan (ForeignPtr GesturePan)+foreign import ccall "gtk_gesture_pan_get_type"+    c_gtk_gesture_pan_get_type :: IO GType++type instance ParentTypes GesturePan = GesturePanParentTypes+type GesturePanParentTypes = '[GestureDrag, GestureSingle, Gesture, EventController, GObject.Object]++instance GObject GesturePan where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_pan_get_type+    ++class GObject o => GesturePanK o+instance (GObject o, IsDescendantOf GesturePan o) => GesturePanK o++toGesturePan :: GesturePanK o => o -> IO GesturePan+toGesturePan = unsafeCastTo GesturePan++noGesturePan :: Maybe GesturePan+noGesturePan = Nothing++-- signal GesturePan::pan+type GesturePanPanCallback =+    PanDirection ->+    Double ->+    IO ()++noGesturePanPanCallback :: Maybe GesturePanPanCallback+noGesturePanPanCallback = Nothing++type GesturePanPanCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGesturePanPanCallback :: GesturePanPanCallbackC -> IO (FunPtr GesturePanPanCallbackC)++gesturePanPanClosure :: GesturePanPanCallback -> IO Closure+gesturePanPanClosure cb = newCClosure =<< mkGesturePanPanCallback wrapped+    where wrapped = gesturePanPanCallbackWrapper cb++gesturePanPanCallbackWrapper ::+    GesturePanPanCallback ->+    Ptr () ->+    CUInt ->+    CDouble ->+    Ptr () ->+    IO ()+gesturePanPanCallbackWrapper _cb _ direction offset _ = do+    let direction' = (toEnum . fromIntegral) direction+    let offset' = realToFrac offset+    _cb  direction' offset'++onGesturePanPan :: (GObject a, MonadIO m) => a -> GesturePanPanCallback -> m SignalHandlerId+onGesturePanPan obj cb = liftIO $ connectGesturePanPan obj cb SignalConnectBefore+afterGesturePanPan :: (GObject a, MonadIO m) => a -> GesturePanPanCallback -> m SignalHandlerId+afterGesturePanPan obj cb = connectGesturePanPan obj cb SignalConnectAfter++connectGesturePanPan :: (GObject a, MonadIO m) =>+                        a -> GesturePanPanCallback -> SignalConnectMode -> m SignalHandlerId+connectGesturePanPan obj cb after = liftIO $ do+    cb' <- mkGesturePanPanCallback (gesturePanPanCallbackWrapper cb)+    connectSignalFunPtr obj "pan" cb' after++-- VVV Prop "orientation"+   -- Type: TInterface "Gtk" "Orientation"+   -- Flags: [PropertyReadable,PropertyWritable]++getGesturePanOrientation :: (MonadIO m, GesturePanK o) => o -> m Orientation+getGesturePanOrientation obj = liftIO $ getObjectPropertyEnum obj "orientation"++setGesturePanOrientation :: (MonadIO m, GesturePanK o) => o -> Orientation -> m ()+setGesturePanOrientation obj val = liftIO $ setObjectPropertyEnum obj "orientation" val++constructGesturePanOrientation :: Orientation -> IO ([Char], GValue)+constructGesturePanOrientation val = constructObjectPropertyEnum "orientation" val++data GesturePanOrientationPropertyInfo+instance AttrInfo GesturePanOrientationPropertyInfo where+    type AttrAllowedOps GesturePanOrientationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GesturePanOrientationPropertyInfo = (~) Orientation+    type AttrBaseTypeConstraint GesturePanOrientationPropertyInfo = GesturePanK+    type AttrGetType GesturePanOrientationPropertyInfo = Orientation+    type AttrLabel GesturePanOrientationPropertyInfo = "GesturePan::orientation"+    attrGet _ = getGesturePanOrientation+    attrSet _ = setGesturePanOrientation+    attrConstruct _ = constructGesturePanOrientation++type instance AttributeList GesturePan = GesturePanAttributeList+type GesturePanAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("orientation", GesturePanOrientationPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GesturePanPanSignalInfo+instance SignalInfo GesturePanPanSignalInfo where+    type HaskellCallbackType GesturePanPanSignalInfo = GesturePanPanCallback+    connectSignal _ = connectGesturePanPan++type instance SignalList GesturePan = GesturePanSignalList+type GesturePanSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("drag-begin", GestureDragDragBeginSignalInfo), '("drag-end", GestureDragDragEndSignalInfo), '("drag-update", GestureDragDragUpdateSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pan", GesturePanPanSignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GesturePan::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GesturePan"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_pan_new" gtk_gesture_pan_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO (Ptr GesturePan)+++gesturePanNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    Orientation ->                          -- orientation+    m GesturePan+gesturePanNew widget orientation = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- gtk_gesture_pan_new widget' orientation'+    checkUnexpectedReturnNULL "gtk_gesture_pan_new" result+    result' <- (wrapObject GesturePan) result+    touchManagedPtr widget+    return result'++-- method GesturePan::get_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GesturePan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GesturePan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Orientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_pan_get_orientation" gtk_gesture_pan_get_orientation :: +    Ptr GesturePan ->                       -- _obj : TInterface "Gtk" "GesturePan"+    IO CUInt+++gesturePanGetOrientation ::+    (MonadIO m, GesturePanK a) =>+    a ->                                    -- _obj+    m Orientation+gesturePanGetOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_pan_get_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method GesturePan::set_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GesturePan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GesturePan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_pan_set_orientation" gtk_gesture_pan_set_orientation :: +    Ptr GesturePan ->                       -- _obj : TInterface "Gtk" "GesturePan"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()+++gesturePanSetOrientation ::+    (MonadIO m, GesturePanK a) =>+    a ->                                    -- _obj+    Orientation ->                          -- orientation+    m ()+gesturePanSetOrientation _obj orientation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_gesture_pan_set_orientation _obj' orientation'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/GesturePan.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.GesturePan where++import Prelude ()+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 GesturePan = GesturePan (ForeignPtr GesturePan)+instance GObject GesturePan where+class GObject o => GesturePanK o+instance (GObject o, IsDescendantOf GesturePan o) => GesturePanK o+data GesturePanOrientationPropertyInfo+data GesturePanPanSignalInfo
+ GI/Gtk/Objects/GestureRotate.hs view
@@ -0,0 +1,186 @@++{- |+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.Gtk.Objects.GestureRotate+    ( ++-- * Exported types+    GestureRotate(..)                       ,+    GestureRotateK                          ,+    toGestureRotate                         ,+    noGestureRotate                         ,+++ -- * Methods+-- ** gestureRotateGetAngleDelta+    gestureRotateGetAngleDelta              ,+++-- ** gestureRotateNew+    gestureRotateNew                        ,+++++ -- * Signals+-- ** AngleChanged+    GestureRotateAngleChangedCallback       ,+    GestureRotateAngleChangedCallbackC      ,+    GestureRotateAngleChangedSignalInfo     ,+    afterGestureRotateAngleChanged          ,+    gestureRotateAngleChangedCallbackWrapper,+    gestureRotateAngleChangedClosure        ,+    mkGestureRotateAngleChangedCallback     ,+    noGestureRotateAngleChangedCallback     ,+    onGestureRotateAngleChanged             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GestureRotate = GestureRotate (ForeignPtr GestureRotate)+foreign import ccall "gtk_gesture_rotate_get_type"+    c_gtk_gesture_rotate_get_type :: IO GType++type instance ParentTypes GestureRotate = GestureRotateParentTypes+type GestureRotateParentTypes = '[Gesture, EventController, GObject.Object]++instance GObject GestureRotate where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_rotate_get_type+    ++class GObject o => GestureRotateK o+instance (GObject o, IsDescendantOf GestureRotate o) => GestureRotateK o++toGestureRotate :: GestureRotateK o => o -> IO GestureRotate+toGestureRotate = unsafeCastTo GestureRotate++noGestureRotate :: Maybe GestureRotate+noGestureRotate = Nothing++-- signal GestureRotate::angle-changed+type GestureRotateAngleChangedCallback =+    Double ->+    Double ->+    IO ()++noGestureRotateAngleChangedCallback :: Maybe GestureRotateAngleChangedCallback+noGestureRotateAngleChangedCallback = Nothing++type GestureRotateAngleChangedCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureRotateAngleChangedCallback :: GestureRotateAngleChangedCallbackC -> IO (FunPtr GestureRotateAngleChangedCallbackC)++gestureRotateAngleChangedClosure :: GestureRotateAngleChangedCallback -> IO Closure+gestureRotateAngleChangedClosure cb = newCClosure =<< mkGestureRotateAngleChangedCallback wrapped+    where wrapped = gestureRotateAngleChangedCallbackWrapper cb++gestureRotateAngleChangedCallbackWrapper ::+    GestureRotateAngleChangedCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureRotateAngleChangedCallbackWrapper _cb _ angle angle_delta _ = do+    let angle' = realToFrac angle+    let angle_delta' = realToFrac angle_delta+    _cb  angle' angle_delta'++onGestureRotateAngleChanged :: (GObject a, MonadIO m) => a -> GestureRotateAngleChangedCallback -> m SignalHandlerId+onGestureRotateAngleChanged obj cb = liftIO $ connectGestureRotateAngleChanged obj cb SignalConnectBefore+afterGestureRotateAngleChanged :: (GObject a, MonadIO m) => a -> GestureRotateAngleChangedCallback -> m SignalHandlerId+afterGestureRotateAngleChanged obj cb = connectGestureRotateAngleChanged obj cb SignalConnectAfter++connectGestureRotateAngleChanged :: (GObject a, MonadIO m) =>+                                    a -> GestureRotateAngleChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureRotateAngleChanged obj cb after = liftIO $ do+    cb' <- mkGestureRotateAngleChangedCallback (gestureRotateAngleChangedCallbackWrapper cb)+    connectSignalFunPtr obj "angle-changed" cb' after++type instance AttributeList GestureRotate = GestureRotateAttributeList+type GestureRotateAttributeList = ('[ '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureRotateAngleChangedSignalInfo+instance SignalInfo GestureRotateAngleChangedSignalInfo where+    type HaskellCallbackType GestureRotateAngleChangedSignalInfo = GestureRotateAngleChangedCallback+    connectSignal _ = connectGestureRotateAngleChanged++type instance SignalList GestureRotate = GestureRotateSignalList+type GestureRotateSignalList = ('[ '("angle-changed", GestureRotateAngleChangedSignalInfo), '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureRotate::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureRotate"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_rotate_new" gtk_gesture_rotate_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureRotate)+++gestureRotateNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureRotate+gestureRotateNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_rotate_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_rotate_new" result+    result' <- (wrapObject GestureRotate) result+    touchManagedPtr widget+    return result'++-- method GestureRotate::get_angle_delta+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureRotate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureRotate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_rotate_get_angle_delta" gtk_gesture_rotate_get_angle_delta :: +    Ptr GestureRotate ->                    -- _obj : TInterface "Gtk" "GestureRotate"+    IO CDouble+++gestureRotateGetAngleDelta ::+    (MonadIO m, GestureRotateK a) =>+    a ->                                    -- _obj+    m Double+gestureRotateGetAngleDelta _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_rotate_get_angle_delta _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/GestureRotate.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.GestureRotate where++import Prelude ()+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 GestureRotate = GestureRotate (ForeignPtr GestureRotate)+instance GObject GestureRotate where+class GObject o => GestureRotateK o+instance (GObject o, IsDescendantOf GestureRotate o) => GestureRotateK o+data GestureRotateAngleChangedSignalInfo
+ GI/Gtk/Objects/GestureSingle.hs view
@@ -0,0 +1,394 @@++{- |+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.Gtk.Objects.GestureSingle+    ( ++-- * Exported types+    GestureSingle(..)                       ,+    GestureSingleK                          ,+    toGestureSingle                         ,+    noGestureSingle                         ,+++ -- * Methods+-- ** gestureSingleGetButton+    gestureSingleGetButton                  ,+++-- ** gestureSingleGetCurrentButton+    gestureSingleGetCurrentButton           ,+++-- ** gestureSingleGetCurrentSequence+    gestureSingleGetCurrentSequence         ,+++-- ** gestureSingleGetExclusive+    gestureSingleGetExclusive               ,+++-- ** gestureSingleGetTouchOnly+    gestureSingleGetTouchOnly               ,+++-- ** gestureSingleSetButton+    gestureSingleSetButton                  ,+++-- ** gestureSingleSetExclusive+    gestureSingleSetExclusive               ,+++-- ** gestureSingleSetTouchOnly+    gestureSingleSetTouchOnly               ,+++++ -- * Properties+-- ** Button+    GestureSingleButtonPropertyInfo         ,+    constructGestureSingleButton            ,+    getGestureSingleButton                  ,+    setGestureSingleButton                  ,+++-- ** Exclusive+    GestureSingleExclusivePropertyInfo      ,+    constructGestureSingleExclusive         ,+    getGestureSingleExclusive               ,+    setGestureSingleExclusive               ,+++-- ** TouchOnly+    GestureSingleTouchOnlyPropertyInfo      ,+    constructGestureSingleTouchOnly         ,+    getGestureSingleTouchOnly               ,+    setGestureSingleTouchOnly               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype GestureSingle = GestureSingle (ForeignPtr GestureSingle)+foreign import ccall "gtk_gesture_single_get_type"+    c_gtk_gesture_single_get_type :: IO GType++type instance ParentTypes GestureSingle = GestureSingleParentTypes+type GestureSingleParentTypes = '[Gesture, EventController, GObject.Object]++instance GObject GestureSingle where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_single_get_type+    ++class GObject o => GestureSingleK o+instance (GObject o, IsDescendantOf GestureSingle o) => GestureSingleK o++toGestureSingle :: GestureSingleK o => o -> IO GestureSingle+toGestureSingle = unsafeCastTo GestureSingle++noGestureSingle :: Maybe GestureSingle+noGestureSingle = Nothing++-- VVV Prop "button"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getGestureSingleButton :: (MonadIO m, GestureSingleK o) => o -> m Word32+getGestureSingleButton obj = liftIO $ getObjectPropertyCUInt obj "button"++setGestureSingleButton :: (MonadIO m, GestureSingleK o) => o -> Word32 -> m ()+setGestureSingleButton obj val = liftIO $ setObjectPropertyCUInt obj "button" val++constructGestureSingleButton :: Word32 -> IO ([Char], GValue)+constructGestureSingleButton val = constructObjectPropertyCUInt "button" val++data GestureSingleButtonPropertyInfo+instance AttrInfo GestureSingleButtonPropertyInfo where+    type AttrAllowedOps GestureSingleButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureSingleButtonPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint GestureSingleButtonPropertyInfo = GestureSingleK+    type AttrGetType GestureSingleButtonPropertyInfo = Word32+    type AttrLabel GestureSingleButtonPropertyInfo = "GestureSingle::button"+    attrGet _ = getGestureSingleButton+    attrSet _ = setGestureSingleButton+    attrConstruct _ = constructGestureSingleButton++-- VVV Prop "exclusive"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGestureSingleExclusive :: (MonadIO m, GestureSingleK o) => o -> m Bool+getGestureSingleExclusive obj = liftIO $ getObjectPropertyBool obj "exclusive"++setGestureSingleExclusive :: (MonadIO m, GestureSingleK o) => o -> Bool -> m ()+setGestureSingleExclusive obj val = liftIO $ setObjectPropertyBool obj "exclusive" val++constructGestureSingleExclusive :: Bool -> IO ([Char], GValue)+constructGestureSingleExclusive val = constructObjectPropertyBool "exclusive" val++data GestureSingleExclusivePropertyInfo+instance AttrInfo GestureSingleExclusivePropertyInfo where+    type AttrAllowedOps GestureSingleExclusivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureSingleExclusivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GestureSingleExclusivePropertyInfo = GestureSingleK+    type AttrGetType GestureSingleExclusivePropertyInfo = Bool+    type AttrLabel GestureSingleExclusivePropertyInfo = "GestureSingle::exclusive"+    attrGet _ = getGestureSingleExclusive+    attrSet _ = setGestureSingleExclusive+    attrConstruct _ = constructGestureSingleExclusive++-- VVV Prop "touch-only"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGestureSingleTouchOnly :: (MonadIO m, GestureSingleK o) => o -> m Bool+getGestureSingleTouchOnly obj = liftIO $ getObjectPropertyBool obj "touch-only"++setGestureSingleTouchOnly :: (MonadIO m, GestureSingleK o) => o -> Bool -> m ()+setGestureSingleTouchOnly obj val = liftIO $ setObjectPropertyBool obj "touch-only" val++constructGestureSingleTouchOnly :: Bool -> IO ([Char], GValue)+constructGestureSingleTouchOnly val = constructObjectPropertyBool "touch-only" val++data GestureSingleTouchOnlyPropertyInfo+instance AttrInfo GestureSingleTouchOnlyPropertyInfo where+    type AttrAllowedOps GestureSingleTouchOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GestureSingleTouchOnlyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GestureSingleTouchOnlyPropertyInfo = GestureSingleK+    type AttrGetType GestureSingleTouchOnlyPropertyInfo = Bool+    type AttrLabel GestureSingleTouchOnlyPropertyInfo = "GestureSingle::touch-only"+    attrGet _ = getGestureSingleTouchOnly+    attrSet _ = setGestureSingleTouchOnly+    attrConstruct _ = constructGestureSingleTouchOnly++type instance AttributeList GestureSingle = GestureSingleAttributeList+type GestureSingleAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList GestureSingle = GestureSingleSignalList+type GestureSingleSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureSingle::get_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_single_get_button" gtk_gesture_single_get_button :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    IO Word32+++gestureSingleGetButton ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    m Word32+gestureSingleGetButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_single_get_button _obj'+    touchManagedPtr _obj+    return result++-- method GestureSingle::get_current_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_single_get_current_button" gtk_gesture_single_get_current_button :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    IO Word32+++gestureSingleGetCurrentButton ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    m Word32+gestureSingleGetCurrentButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_single_get_current_button _obj'+    touchManagedPtr _obj+    return result++-- method GestureSingle::get_current_sequence+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "EventSequence"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_single_get_current_sequence" gtk_gesture_single_get_current_sequence :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    IO (Ptr Gdk.EventSequence)+++gestureSingleGetCurrentSequence ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    m Gdk.EventSequence+gestureSingleGetCurrentSequence _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_single_get_current_sequence _obj'+    checkUnexpectedReturnNULL "gtk_gesture_single_get_current_sequence" result+    result' <- (wrapBoxed Gdk.EventSequence) result+    touchManagedPtr _obj+    return result'++-- method GestureSingle::get_exclusive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_single_get_exclusive" gtk_gesture_single_get_exclusive :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    IO CInt+++gestureSingleGetExclusive ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    m Bool+gestureSingleGetExclusive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_single_get_exclusive _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GestureSingle::get_touch_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_single_get_touch_only" gtk_gesture_single_get_touch_only :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    IO CInt+++gestureSingleGetTouchOnly ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    m Bool+gestureSingleGetTouchOnly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_single_get_touch_only _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method GestureSingle::set_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", 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 "gtk_gesture_single_set_button" gtk_gesture_single_set_button :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    Word32 ->                               -- button : TBasicType TUInt32+    IO ()+++gestureSingleSetButton ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- button+    m ()+gestureSingleSetButton _obj button = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_gesture_single_set_button _obj' button+    touchManagedPtr _obj+    return ()++-- method GestureSingle::set_exclusive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exclusive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "exclusive", 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 "gtk_gesture_single_set_exclusive" gtk_gesture_single_set_exclusive :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    CInt ->                                 -- exclusive : TBasicType TBoolean+    IO ()+++gestureSingleSetExclusive ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- exclusive+    m ()+gestureSingleSetExclusive _obj exclusive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let exclusive' = (fromIntegral . fromEnum) exclusive+    gtk_gesture_single_set_exclusive _obj' exclusive'+    touchManagedPtr _obj+    return ()++-- method GestureSingle::set_touch_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "touch_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSingle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "touch_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 "gtk_gesture_single_set_touch_only" gtk_gesture_single_set_touch_only :: +    Ptr GestureSingle ->                    -- _obj : TInterface "Gtk" "GestureSingle"+    CInt ->                                 -- touch_only : TBasicType TBoolean+    IO ()+++gestureSingleSetTouchOnly ::+    (MonadIO m, GestureSingleK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- touch_only+    m ()+gestureSingleSetTouchOnly _obj touch_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let touch_only' = (fromIntegral . fromEnum) touch_only+    gtk_gesture_single_set_touch_only _obj' touch_only'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/GestureSingle.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.GestureSingle where++import Prelude ()+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 GestureSingle = GestureSingle (ForeignPtr GestureSingle)+instance GObject GestureSingle where+class GObject o => GestureSingleK o+instance (GObject o, IsDescendantOf GestureSingle o) => GestureSingleK o+data GestureSingleButtonPropertyInfo+data GestureSingleExclusivePropertyInfo+data GestureSingleTouchOnlyPropertyInfo
+ GI/Gtk/Objects/GestureSwipe.hs view
@@ -0,0 +1,196 @@++{- |+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.Gtk.Objects.GestureSwipe+    ( ++-- * Exported types+    GestureSwipe(..)                        ,+    GestureSwipeK                           ,+    toGestureSwipe                          ,+    noGestureSwipe                          ,+++ -- * Methods+-- ** gestureSwipeGetVelocity+    gestureSwipeGetVelocity                 ,+++-- ** gestureSwipeNew+    gestureSwipeNew                         ,+++++ -- * Signals+-- ** Swipe+    GestureSwipeSwipeCallback               ,+    GestureSwipeSwipeCallbackC              ,+    GestureSwipeSwipeSignalInfo             ,+    afterGestureSwipeSwipe                  ,+    gestureSwipeSwipeCallbackWrapper        ,+    gestureSwipeSwipeClosure                ,+    mkGestureSwipeSwipeCallback             ,+    noGestureSwipeSwipeCallback             ,+    onGestureSwipeSwipe                     ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GestureSwipe = GestureSwipe (ForeignPtr GestureSwipe)+foreign import ccall "gtk_gesture_swipe_get_type"+    c_gtk_gesture_swipe_get_type :: IO GType++type instance ParentTypes GestureSwipe = GestureSwipeParentTypes+type GestureSwipeParentTypes = '[GestureSingle, Gesture, EventController, GObject.Object]++instance GObject GestureSwipe where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_swipe_get_type+    ++class GObject o => GestureSwipeK o+instance (GObject o, IsDescendantOf GestureSwipe o) => GestureSwipeK o++toGestureSwipe :: GestureSwipeK o => o -> IO GestureSwipe+toGestureSwipe = unsafeCastTo GestureSwipe++noGestureSwipe :: Maybe GestureSwipe+noGestureSwipe = Nothing++-- signal GestureSwipe::swipe+type GestureSwipeSwipeCallback =+    Double ->+    Double ->+    IO ()++noGestureSwipeSwipeCallback :: Maybe GestureSwipeSwipeCallback+noGestureSwipeSwipeCallback = Nothing++type GestureSwipeSwipeCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureSwipeSwipeCallback :: GestureSwipeSwipeCallbackC -> IO (FunPtr GestureSwipeSwipeCallbackC)++gestureSwipeSwipeClosure :: GestureSwipeSwipeCallback -> IO Closure+gestureSwipeSwipeClosure cb = newCClosure =<< mkGestureSwipeSwipeCallback wrapped+    where wrapped = gestureSwipeSwipeCallbackWrapper cb++gestureSwipeSwipeCallbackWrapper ::+    GestureSwipeSwipeCallback ->+    Ptr () ->+    CDouble ->+    CDouble ->+    Ptr () ->+    IO ()+gestureSwipeSwipeCallbackWrapper _cb _ velocity_x velocity_y _ = do+    let velocity_x' = realToFrac velocity_x+    let velocity_y' = realToFrac velocity_y+    _cb  velocity_x' velocity_y'++onGestureSwipeSwipe :: (GObject a, MonadIO m) => a -> GestureSwipeSwipeCallback -> m SignalHandlerId+onGestureSwipeSwipe obj cb = liftIO $ connectGestureSwipeSwipe obj cb SignalConnectBefore+afterGestureSwipeSwipe :: (GObject a, MonadIO m) => a -> GestureSwipeSwipeCallback -> m SignalHandlerId+afterGestureSwipeSwipe obj cb = connectGestureSwipeSwipe obj cb SignalConnectAfter++connectGestureSwipeSwipe :: (GObject a, MonadIO m) =>+                            a -> GestureSwipeSwipeCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureSwipeSwipe obj cb after = liftIO $ do+    cb' <- mkGestureSwipeSwipeCallback (gestureSwipeSwipeCallbackWrapper cb)+    connectSignalFunPtr obj "swipe" cb' after++type instance AttributeList GestureSwipe = GestureSwipeAttributeList+type GestureSwipeAttributeList = ('[ '("button", GestureSingleButtonPropertyInfo), '("exclusive", GestureSingleExclusivePropertyInfo), '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("touch-only", GestureSingleTouchOnlyPropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureSwipeSwipeSignalInfo+instance SignalInfo GestureSwipeSwipeSignalInfo where+    type HaskellCallbackType GestureSwipeSwipeSignalInfo = GestureSwipeSwipeCallback+    connectSignal _ = connectGestureSwipeSwipe++type instance SignalList GestureSwipe = GestureSwipeSignalList+type GestureSwipeSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("swipe", GestureSwipeSwipeSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureSwipe::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureSwipe"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_swipe_new" gtk_gesture_swipe_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureSwipe)+++gestureSwipeNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureSwipe+gestureSwipeNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_swipe_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_swipe_new" result+    result' <- (wrapObject GestureSwipe) result+    touchManagedPtr widget+    return result'++-- method GestureSwipe::get_velocity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSwipe", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "velocity_x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "velocity_y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureSwipe", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_swipe_get_velocity" gtk_gesture_swipe_get_velocity :: +    Ptr GestureSwipe ->                     -- _obj : TInterface "Gtk" "GestureSwipe"+    Ptr CDouble ->                          -- velocity_x : TBasicType TDouble+    Ptr CDouble ->                          -- velocity_y : TBasicType TDouble+    IO CInt+++gestureSwipeGetVelocity ::+    (MonadIO m, GestureSwipeK a) =>+    a ->                                    -- _obj+    m (Bool,Double,Double)+gestureSwipeGetVelocity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    velocity_x <- allocMem :: IO (Ptr CDouble)+    velocity_y <- allocMem :: IO (Ptr CDouble)+    result <- gtk_gesture_swipe_get_velocity _obj' velocity_x velocity_y+    let result' = (/= 0) result+    velocity_x' <- peek velocity_x+    let velocity_x'' = realToFrac velocity_x'+    velocity_y' <- peek velocity_y+    let velocity_y'' = realToFrac velocity_y'+    touchManagedPtr _obj+    freeMem velocity_x+    freeMem velocity_y+    return (result', velocity_x'', velocity_y'')++
+ GI/Gtk/Objects/GestureSwipe.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.GestureSwipe where++import Prelude ()+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 GestureSwipe = GestureSwipe (ForeignPtr GestureSwipe)+instance GObject GestureSwipe where+class GObject o => GestureSwipeK o+instance (GObject o, IsDescendantOf GestureSwipe o) => GestureSwipeK o+data GestureSwipeSwipeSignalInfo
+ GI/Gtk/Objects/GestureZoom.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.Gtk.Objects.GestureZoom+    ( ++-- * Exported types+    GestureZoom(..)                         ,+    GestureZoomK                            ,+    toGestureZoom                           ,+    noGestureZoom                           ,+++ -- * Methods+-- ** gestureZoomGetScaleDelta+    gestureZoomGetScaleDelta                ,+++-- ** gestureZoomNew+    gestureZoomNew                          ,+++++ -- * Signals+-- ** ScaleChanged+    GestureZoomScaleChangedCallback         ,+    GestureZoomScaleChangedCallbackC        ,+    GestureZoomScaleChangedSignalInfo       ,+    afterGestureZoomScaleChanged            ,+    gestureZoomScaleChangedCallbackWrapper  ,+    gestureZoomScaleChangedClosure          ,+    mkGestureZoomScaleChangedCallback       ,+    noGestureZoomScaleChangedCallback       ,+    onGestureZoomScaleChanged               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype GestureZoom = GestureZoom (ForeignPtr GestureZoom)+foreign import ccall "gtk_gesture_zoom_get_type"+    c_gtk_gesture_zoom_get_type :: IO GType++type instance ParentTypes GestureZoom = GestureZoomParentTypes+type GestureZoomParentTypes = '[Gesture, EventController, GObject.Object]++instance GObject GestureZoom where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_gesture_zoom_get_type+    ++class GObject o => GestureZoomK o+instance (GObject o, IsDescendantOf GestureZoom o) => GestureZoomK o++toGestureZoom :: GestureZoomK o => o -> IO GestureZoom+toGestureZoom = unsafeCastTo GestureZoom++noGestureZoom :: Maybe GestureZoom+noGestureZoom = Nothing++-- signal GestureZoom::scale-changed+type GestureZoomScaleChangedCallback =+    Double ->+    IO ()++noGestureZoomScaleChangedCallback :: Maybe GestureZoomScaleChangedCallback+noGestureZoomScaleChangedCallback = Nothing++type GestureZoomScaleChangedCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkGestureZoomScaleChangedCallback :: GestureZoomScaleChangedCallbackC -> IO (FunPtr GestureZoomScaleChangedCallbackC)++gestureZoomScaleChangedClosure :: GestureZoomScaleChangedCallback -> IO Closure+gestureZoomScaleChangedClosure cb = newCClosure =<< mkGestureZoomScaleChangedCallback wrapped+    where wrapped = gestureZoomScaleChangedCallbackWrapper cb++gestureZoomScaleChangedCallbackWrapper ::+    GestureZoomScaleChangedCallback ->+    Ptr () ->+    CDouble ->+    Ptr () ->+    IO ()+gestureZoomScaleChangedCallbackWrapper _cb _ scale _ = do+    let scale' = realToFrac scale+    _cb  scale'++onGestureZoomScaleChanged :: (GObject a, MonadIO m) => a -> GestureZoomScaleChangedCallback -> m SignalHandlerId+onGestureZoomScaleChanged obj cb = liftIO $ connectGestureZoomScaleChanged obj cb SignalConnectBefore+afterGestureZoomScaleChanged :: (GObject a, MonadIO m) => a -> GestureZoomScaleChangedCallback -> m SignalHandlerId+afterGestureZoomScaleChanged obj cb = connectGestureZoomScaleChanged obj cb SignalConnectAfter++connectGestureZoomScaleChanged :: (GObject a, MonadIO m) =>+                                  a -> GestureZoomScaleChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectGestureZoomScaleChanged obj cb after = liftIO $ do+    cb' <- mkGestureZoomScaleChangedCallback (gestureZoomScaleChangedCallbackWrapper cb)+    connectSignalFunPtr obj "scale-changed" cb' after++type instance AttributeList GestureZoom = GestureZoomAttributeList+type GestureZoomAttributeList = ('[ '("n-points", GestureNPointsPropertyInfo), '("propagation-phase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo), '("window", GestureWindowPropertyInfo)] :: [(Symbol, *)])++data GestureZoomScaleChangedSignalInfo+instance SignalInfo GestureZoomScaleChangedSignalInfo where+    type HaskellCallbackType GestureZoomScaleChangedSignalInfo = GestureZoomScaleChangedCallback+    connectSignal _ = connectGestureZoomScaleChanged++type instance SignalList GestureZoom = GestureZoomSignalList+type GestureZoomSignalList = ('[ '("begin", GestureBeginSignalInfo), '("cancel", GestureCancelSignalInfo), '("end", GestureEndSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("scale-changed", GestureZoomScaleChangedSignalInfo), '("sequence-state-changed", GestureSequenceStateChangedSignalInfo), '("update", GestureUpdateSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method GestureZoom::new+-- method type : Constructor+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "GestureZoom"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_zoom_new" gtk_gesture_zoom_new :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr GestureZoom)+++gestureZoomNew ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m GestureZoom+gestureZoomNew widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_gesture_zoom_new widget'+    checkUnexpectedReturnNULL "gtk_gesture_zoom_new" result+    result' <- (wrapObject GestureZoom) result+    touchManagedPtr widget+    return result'++-- method GestureZoom::get_scale_delta+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureZoom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "GestureZoom", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_gesture_zoom_get_scale_delta" gtk_gesture_zoom_get_scale_delta :: +    Ptr GestureZoom ->                      -- _obj : TInterface "Gtk" "GestureZoom"+    IO CDouble+++gestureZoomGetScaleDelta ::+    (MonadIO m, GestureZoomK a) =>+    a ->                                    -- _obj+    m Double+gestureZoomGetScaleDelta _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_gesture_zoom_get_scale_delta _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/GestureZoom.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.GestureZoom where++import Prelude ()+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 GestureZoom = GestureZoom (ForeignPtr GestureZoom)+instance GObject GestureZoom where+class GObject o => GestureZoomK o+instance (GObject o, IsDescendantOf GestureZoom o) => GestureZoomK o+data GestureZoomScaleChangedSignalInfo
+ GI/Gtk/Objects/Grid.hs view
@@ -0,0 +1,880 @@++{- |+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.Gtk.Objects.Grid+    ( ++-- * Exported types+    Grid(..)                                ,+    GridK                                   ,+    toGrid                                  ,+    noGrid                                  ,+++ -- * Methods+-- ** gridAttach+    gridAttach                              ,+++-- ** gridAttachNextTo+    gridAttachNextTo                        ,+++-- ** gridGetBaselineRow+    gridGetBaselineRow                      ,+++-- ** gridGetChildAt+    gridGetChildAt                          ,+++-- ** gridGetColumnHomogeneous+    gridGetColumnHomogeneous                ,+++-- ** gridGetColumnSpacing+    gridGetColumnSpacing                    ,+++-- ** gridGetRowBaselinePosition+    gridGetRowBaselinePosition              ,+++-- ** gridGetRowHomogeneous+    gridGetRowHomogeneous                   ,+++-- ** gridGetRowSpacing+    gridGetRowSpacing                       ,+++-- ** gridInsertColumn+    gridInsertColumn                        ,+++-- ** gridInsertNextTo+    gridInsertNextTo                        ,+++-- ** gridInsertRow+    gridInsertRow                           ,+++-- ** gridNew+    gridNew                                 ,+++-- ** gridRemoveColumn+    gridRemoveColumn                        ,+++-- ** gridRemoveRow+    gridRemoveRow                           ,+++-- ** gridSetBaselineRow+    gridSetBaselineRow                      ,+++-- ** gridSetColumnHomogeneous+    gridSetColumnHomogeneous                ,+++-- ** gridSetColumnSpacing+    gridSetColumnSpacing                    ,+++-- ** gridSetRowBaselinePosition+    gridSetRowBaselinePosition              ,+++-- ** gridSetRowHomogeneous+    gridSetRowHomogeneous                   ,+++-- ** gridSetRowSpacing+    gridSetRowSpacing                       ,+++++ -- * Properties+-- ** BaselineRow+    GridBaselineRowPropertyInfo             ,+    constructGridBaselineRow                ,+    getGridBaselineRow                      ,+    setGridBaselineRow                      ,+++-- ** ColumnHomogeneous+    GridColumnHomogeneousPropertyInfo       ,+    constructGridColumnHomogeneous          ,+    getGridColumnHomogeneous                ,+    setGridColumnHomogeneous                ,+++-- ** ColumnSpacing+    GridColumnSpacingPropertyInfo           ,+    constructGridColumnSpacing              ,+    getGridColumnSpacing                    ,+    setGridColumnSpacing                    ,+++-- ** RowHomogeneous+    GridRowHomogeneousPropertyInfo          ,+    constructGridRowHomogeneous             ,+    getGridRowHomogeneous                   ,+    setGridRowHomogeneous                   ,+++-- ** RowSpacing+    GridRowSpacingPropertyInfo              ,+    constructGridRowSpacing                 ,+    getGridRowSpacing                       ,+    setGridRowSpacing                       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Grid = Grid (ForeignPtr Grid)+foreign import ccall "gtk_grid_get_type"+    c_gtk_grid_get_type :: IO GType++type instance ParentTypes Grid = GridParentTypes+type GridParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject Grid where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_grid_get_type+    ++class GObject o => GridK o+instance (GObject o, IsDescendantOf Grid o) => GridK o++toGrid :: GridK o => o -> IO Grid+toGrid = unsafeCastTo Grid++noGrid :: Maybe Grid+noGrid = Nothing++-- VVV Prop "baseline-row"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getGridBaselineRow :: (MonadIO m, GridK o) => o -> m Int32+getGridBaselineRow obj = liftIO $ getObjectPropertyCInt obj "baseline-row"++setGridBaselineRow :: (MonadIO m, GridK o) => o -> Int32 -> m ()+setGridBaselineRow obj val = liftIO $ setObjectPropertyCInt obj "baseline-row" val++constructGridBaselineRow :: Int32 -> IO ([Char], GValue)+constructGridBaselineRow val = constructObjectPropertyCInt "baseline-row" val++data GridBaselineRowPropertyInfo+instance AttrInfo GridBaselineRowPropertyInfo where+    type AttrAllowedOps GridBaselineRowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GridBaselineRowPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint GridBaselineRowPropertyInfo = GridK+    type AttrGetType GridBaselineRowPropertyInfo = Int32+    type AttrLabel GridBaselineRowPropertyInfo = "Grid::baseline-row"+    attrGet _ = getGridBaselineRow+    attrSet _ = setGridBaselineRow+    attrConstruct _ = constructGridBaselineRow++-- VVV Prop "column-homogeneous"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGridColumnHomogeneous :: (MonadIO m, GridK o) => o -> m Bool+getGridColumnHomogeneous obj = liftIO $ getObjectPropertyBool obj "column-homogeneous"++setGridColumnHomogeneous :: (MonadIO m, GridK o) => o -> Bool -> m ()+setGridColumnHomogeneous obj val = liftIO $ setObjectPropertyBool obj "column-homogeneous" val++constructGridColumnHomogeneous :: Bool -> IO ([Char], GValue)+constructGridColumnHomogeneous val = constructObjectPropertyBool "column-homogeneous" val++data GridColumnHomogeneousPropertyInfo+instance AttrInfo GridColumnHomogeneousPropertyInfo where+    type AttrAllowedOps GridColumnHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GridColumnHomogeneousPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GridColumnHomogeneousPropertyInfo = GridK+    type AttrGetType GridColumnHomogeneousPropertyInfo = Bool+    type AttrLabel GridColumnHomogeneousPropertyInfo = "Grid::column-homogeneous"+    attrGet _ = getGridColumnHomogeneous+    attrSet _ = setGridColumnHomogeneous+    attrConstruct _ = constructGridColumnHomogeneous++-- VVV Prop "column-spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getGridColumnSpacing :: (MonadIO m, GridK o) => o -> m Int32+getGridColumnSpacing obj = liftIO $ getObjectPropertyCInt obj "column-spacing"++setGridColumnSpacing :: (MonadIO m, GridK o) => o -> Int32 -> m ()+setGridColumnSpacing obj val = liftIO $ setObjectPropertyCInt obj "column-spacing" val++constructGridColumnSpacing :: Int32 -> IO ([Char], GValue)+constructGridColumnSpacing val = constructObjectPropertyCInt "column-spacing" val++data GridColumnSpacingPropertyInfo+instance AttrInfo GridColumnSpacingPropertyInfo where+    type AttrAllowedOps GridColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GridColumnSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint GridColumnSpacingPropertyInfo = GridK+    type AttrGetType GridColumnSpacingPropertyInfo = Int32+    type AttrLabel GridColumnSpacingPropertyInfo = "Grid::column-spacing"+    attrGet _ = getGridColumnSpacing+    attrSet _ = setGridColumnSpacing+    attrConstruct _ = constructGridColumnSpacing++-- VVV Prop "row-homogeneous"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getGridRowHomogeneous :: (MonadIO m, GridK o) => o -> m Bool+getGridRowHomogeneous obj = liftIO $ getObjectPropertyBool obj "row-homogeneous"++setGridRowHomogeneous :: (MonadIO m, GridK o) => o -> Bool -> m ()+setGridRowHomogeneous obj val = liftIO $ setObjectPropertyBool obj "row-homogeneous" val++constructGridRowHomogeneous :: Bool -> IO ([Char], GValue)+constructGridRowHomogeneous val = constructObjectPropertyBool "row-homogeneous" val++data GridRowHomogeneousPropertyInfo+instance AttrInfo GridRowHomogeneousPropertyInfo where+    type AttrAllowedOps GridRowHomogeneousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GridRowHomogeneousPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint GridRowHomogeneousPropertyInfo = GridK+    type AttrGetType GridRowHomogeneousPropertyInfo = Bool+    type AttrLabel GridRowHomogeneousPropertyInfo = "Grid::row-homogeneous"+    attrGet _ = getGridRowHomogeneous+    attrSet _ = setGridRowHomogeneous+    attrConstruct _ = constructGridRowHomogeneous++-- VVV Prop "row-spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getGridRowSpacing :: (MonadIO m, GridK o) => o -> m Int32+getGridRowSpacing obj = liftIO $ getObjectPropertyCInt obj "row-spacing"++setGridRowSpacing :: (MonadIO m, GridK o) => o -> Int32 -> m ()+setGridRowSpacing obj val = liftIO $ setObjectPropertyCInt obj "row-spacing" val++constructGridRowSpacing :: Int32 -> IO ([Char], GValue)+constructGridRowSpacing val = constructObjectPropertyCInt "row-spacing" val++data GridRowSpacingPropertyInfo+instance AttrInfo GridRowSpacingPropertyInfo where+    type AttrAllowedOps GridRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint GridRowSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint GridRowSpacingPropertyInfo = GridK+    type AttrGetType GridRowSpacingPropertyInfo = Int32+    type AttrLabel GridRowSpacingPropertyInfo = "Grid::row-spacing"+    attrGet _ = getGridRowSpacing+    attrSet _ = setGridRowSpacing+    attrConstruct _ = constructGridRowSpacing++type instance AttributeList Grid = GridAttributeList+type GridAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-row", GridBaselineRowPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-homogeneous", GridColumnHomogeneousPropertyInfo), '("column-spacing", GridColumnSpacingPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-homogeneous", GridRowHomogeneousPropertyInfo), '("row-spacing", GridRowSpacingPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Grid = GridSignalList+type GridSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Grid::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Grid"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_new" gtk_grid_new :: +    IO (Ptr Grid)+++gridNew ::+    (MonadIO m) =>+    m Grid+gridNew  = liftIO $ do+    result <- gtk_grid_new+    checkUnexpectedReturnNULL "gtk_grid_new" result+    result' <- (newObject Grid) result+    return result'++-- method Grid::attach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_grid_attach" gtk_grid_attach :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- left : TBasicType TInt32+    Int32 ->                                -- top : TBasicType TInt32+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()+++gridAttach ::+    (MonadIO m, GridK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- left+    Int32 ->                                -- top+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+gridAttach _obj child left top width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_grid_attach _obj' child' left top width height+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Grid::attach_next_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_grid_attach_next_to" gtk_grid_attach_next_to :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- sibling : TInterface "Gtk" "Widget"+    CUInt ->                                -- side : TInterface "Gtk" "PositionType"+    Int32 ->                                -- width : TBasicType TInt32+    Int32 ->                                -- height : TBasicType TInt32+    IO ()+++gridAttachNextTo ::+    (MonadIO m, GridK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- sibling+    PositionType ->                         -- side+    Int32 ->                                -- width+    Int32 ->                                -- height+    m ()+gridAttachNextTo _obj child sibling side width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeSibling <- case sibling of+        Nothing -> return nullPtr+        Just jSibling -> do+            let jSibling' = unsafeManagedPtrCastPtr jSibling+            return jSibling'+    let side' = (fromIntegral . fromEnum) side+    gtk_grid_attach_next_to _obj' child' maybeSibling side' width height+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust sibling touchManagedPtr+    return ()++-- method Grid::get_baseline_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_baseline_row" gtk_grid_get_baseline_row :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    IO Int32+++gridGetBaselineRow ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    m Int32+gridGetBaselineRow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_baseline_row _obj'+    touchManagedPtr _obj+    return result++-- method Grid::get_child_at+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_child_at" gtk_grid_get_child_at :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- left : TBasicType TInt32+    Int32 ->                                -- top : TBasicType TInt32+    IO (Ptr Widget)+++gridGetChildAt ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- left+    Int32 ->                                -- top+    m Widget+gridGetChildAt _obj left top = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_child_at _obj' left top+    checkUnexpectedReturnNULL "gtk_grid_get_child_at" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Grid::get_column_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_column_homogeneous" gtk_grid_get_column_homogeneous :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    IO CInt+++gridGetColumnHomogeneous ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    m Bool+gridGetColumnHomogeneous _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_column_homogeneous _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Grid::get_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_column_spacing" gtk_grid_get_column_spacing :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    IO Word32+++gridGetColumnSpacing ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    m Word32+gridGetColumnSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_column_spacing _obj'+    touchManagedPtr _obj+    return result++-- method Grid::get_row_baseline_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "BaselinePosition"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_row_baseline_position" gtk_grid_get_row_baseline_position :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- row : TBasicType TInt32+    IO CUInt+++gridGetRowBaselinePosition ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- row+    m BaselinePosition+gridGetRowBaselinePosition _obj row = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_row_baseline_position _obj' row+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Grid::get_row_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_row_homogeneous" gtk_grid_get_row_homogeneous :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    IO CInt+++gridGetRowHomogeneous ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    m Bool+gridGetRowHomogeneous _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_row_homogeneous _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Grid::get_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_get_row_spacing" gtk_grid_get_row_spacing :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    IO Word32+++gridGetRowSpacing ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    m Word32+gridGetRowSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_grid_get_row_spacing _obj'+    touchManagedPtr _obj+    return result++-- method Grid::insert_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", 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 "Gtk" "Grid", 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 "gtk_grid_insert_column" gtk_grid_insert_column :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++gridInsertColumn ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+gridInsertColumn _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_insert_column _obj' position+    touchManagedPtr _obj+    return ()++-- method Grid::insert_next_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "side", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_insert_next_to" gtk_grid_insert_next_to :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Ptr Widget ->                           -- sibling : TInterface "Gtk" "Widget"+    CUInt ->                                -- side : TInterface "Gtk" "PositionType"+    IO ()+++gridInsertNextTo ::+    (MonadIO m, GridK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- sibling+    PositionType ->                         -- side+    m ()+gridInsertNextTo _obj sibling side = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sibling' = unsafeManagedPtrCastPtr sibling+    let side' = (fromIntegral . fromEnum) side+    gtk_grid_insert_next_to _obj' sibling' side'+    touchManagedPtr _obj+    touchManagedPtr sibling+    return ()++-- method Grid::insert_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", 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 "Gtk" "Grid", 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 "gtk_grid_insert_row" gtk_grid_insert_row :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++gridInsertRow ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+gridInsertRow _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_insert_row _obj' position+    touchManagedPtr _obj+    return ()++-- method Grid::remove_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", 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 "Gtk" "Grid", 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 "gtk_grid_remove_column" gtk_grid_remove_column :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++gridRemoveColumn ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+gridRemoveColumn _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_remove_column _obj' position+    touchManagedPtr _obj+    return ()++-- method Grid::remove_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", 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 "Gtk" "Grid", 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 "gtk_grid_remove_row" gtk_grid_remove_row :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++gridRemoveRow ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+gridRemoveRow _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_remove_row _obj' position+    touchManagedPtr _obj+    return ()++-- method Grid::set_baseline_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", 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 "gtk_grid_set_baseline_row" gtk_grid_set_baseline_row :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- row : TBasicType TInt32+    IO ()+++gridSetBaselineRow ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- row+    m ()+gridSetBaselineRow _obj row = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_set_baseline_row _obj' row+    touchManagedPtr _obj+    return ()++-- method Grid::set_column_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", 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 "gtk_grid_set_column_homogeneous" gtk_grid_set_column_homogeneous :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    CInt ->                                 -- homogeneous : TBasicType TBoolean+    IO ()+++gridSetColumnHomogeneous ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- homogeneous+    m ()+gridSetColumnHomogeneous _obj homogeneous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    gtk_grid_set_column_homogeneous _obj' homogeneous'+    touchManagedPtr _obj+    return ()++-- method Grid::set_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_grid_set_column_spacing" gtk_grid_set_column_spacing :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Word32 ->                               -- spacing : TBasicType TUInt32+    IO ()+++gridSetColumnSpacing ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- spacing+    m ()+gridSetColumnSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_set_column_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++-- method Grid::set_row_baseline_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "BaselinePosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "BaselinePosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_grid_set_row_baseline_position" gtk_grid_set_row_baseline_position :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Int32 ->                                -- row : TBasicType TInt32+    CUInt ->                                -- pos : TInterface "Gtk" "BaselinePosition"+    IO ()+++gridSetRowBaselinePosition ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- row+    BaselinePosition ->                     -- pos+    m ()+gridSetRowBaselinePosition _obj row pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pos' = (fromIntegral . fromEnum) pos+    gtk_grid_set_row_baseline_position _obj' row pos'+    touchManagedPtr _obj+    return ()++-- method Grid::set_row_homogeneous+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "homogeneous", 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 "gtk_grid_set_row_homogeneous" gtk_grid_set_row_homogeneous :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    CInt ->                                 -- homogeneous : TBasicType TBoolean+    IO ()+++gridSetRowHomogeneous ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- homogeneous+    m ()+gridSetRowHomogeneous _obj homogeneous = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    gtk_grid_set_row_homogeneous _obj' homogeneous'+    touchManagedPtr _obj+    return ()++-- method Grid::set_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Grid", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_grid_set_row_spacing" gtk_grid_set_row_spacing :: +    Ptr Grid ->                             -- _obj : TInterface "Gtk" "Grid"+    Word32 ->                               -- spacing : TBasicType TUInt32+    IO ()+++gridSetRowSpacing ::+    (MonadIO m, GridK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- spacing+    m ()+gridSetRowSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_grid_set_row_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Grid.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.Grid where++import Prelude ()+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 Grid = Grid (ForeignPtr Grid)+instance GObject Grid where+class GObject o => GridK o+instance (GObject o, IsDescendantOf Grid o) => GridK o+data GridBaselineRowPropertyInfo+data GridColumnHomogeneousPropertyInfo+data GridColumnSpacingPropertyInfo+data GridRowHomogeneousPropertyInfo+data GridRowSpacingPropertyInfo
+ GI/Gtk/Objects/HBox.hs view
@@ -0,0 +1,93 @@++{- |+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.Gtk.Objects.HBox+    ( ++-- * Exported types+    HBox(..)                                ,+    HBoxK                                   ,+    toHBox                                  ,+    noHBox                                  ,+++ -- * Methods+-- ** hBoxNew+    hBoxNew                                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HBox = HBox (ForeignPtr HBox)+foreign import ccall "gtk_hbox_get_type"+    c_gtk_hbox_get_type :: IO GType++type instance ParentTypes HBox = HBoxParentTypes+type HBoxParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hbox_get_type+    ++class GObject o => HBoxK o+instance (GObject o, IsDescendantOf HBox o) => HBoxK o++toHBox :: HBoxK o => o -> IO HBox+toHBox = unsafeCastTo HBox++noHBox :: Maybe HBox+noHBox = Nothing++type instance AttributeList HBox = HBoxAttributeList+type HBoxAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HBox = HBoxSignalList+type HBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HBox::new+-- method type : Constructor+-- Args : [Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "homogeneous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "HBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hbox_new" gtk_hbox_new :: +    CInt ->                                 -- homogeneous : TBasicType TBoolean+    Int32 ->                                -- spacing : TBasicType TInt32+    IO (Ptr HBox)++{-# DEPRECATED hBoxNew ["(Since version 3.2)","You can use gtk_box_new() with %GTK_ORIENTATION_HORIZONTAL instead,","  which is a quick and easy change. But the recommendation is to switch to","  #GtkGrid, since #GtkBox is going to go away eventually.","  See [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid]."]#-}+hBoxNew ::+    (MonadIO m) =>+    Bool ->                                 -- homogeneous+    Int32 ->                                -- spacing+    m HBox+hBoxNew homogeneous spacing = liftIO $ do+    let homogeneous' = (fromIntegral . fromEnum) homogeneous+    result <- gtk_hbox_new homogeneous' spacing+    checkUnexpectedReturnNULL "gtk_hbox_new" result+    result' <- (newObject HBox) result+    return result'++
+ GI/Gtk/Objects/HBox.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HBox where++import Prelude ()+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 HBox = HBox (ForeignPtr HBox)+instance GObject HBox where+class GObject o => HBoxK o+instance (GObject o, IsDescendantOf HBox o) => HBoxK o
+ GI/Gtk/Objects/HButtonBox.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.Gtk.Objects.HButtonBox+    ( ++-- * Exported types+    HButtonBox(..)                          ,+    HButtonBoxK                             ,+    toHButtonBox                            ,+    noHButtonBox                            ,+++ -- * Methods+-- ** hButtonBoxNew+    hButtonBoxNew                           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HButtonBox = HButtonBox (ForeignPtr HButtonBox)+foreign import ccall "gtk_hbutton_box_get_type"+    c_gtk_hbutton_box_get_type :: IO GType++type instance ParentTypes HButtonBox = HButtonBoxParentTypes+type HButtonBoxParentTypes = '[ButtonBox, Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HButtonBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hbutton_box_get_type+    ++class GObject o => HButtonBoxK o+instance (GObject o, IsDescendantOf HButtonBox o) => HButtonBoxK o++toHButtonBox :: HButtonBoxK o => o -> IO HButtonBox+toHButtonBox = unsafeCastTo HButtonBox++noHButtonBox :: Maybe HButtonBox+noHButtonBox = Nothing++type instance AttributeList HButtonBox = HButtonBoxAttributeList+type HButtonBoxAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("layout-style", ButtonBoxLayoutStylePropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HButtonBox = HButtonBoxSignalList+type HButtonBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HButtonBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HButtonBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hbutton_box_new" gtk_hbutton_box_new :: +    IO (Ptr HButtonBox)++{-# DEPRECATED hButtonBoxNew ["(Since version 3.2)","Use gtk_button_box_new() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hButtonBoxNew ::+    (MonadIO m) =>+    m HButtonBox+hButtonBoxNew  = liftIO $ do+    result <- gtk_hbutton_box_new+    checkUnexpectedReturnNULL "gtk_hbutton_box_new" result+    result' <- (newObject HButtonBox) result+    return result'++
+ GI/Gtk/Objects/HButtonBox.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HButtonBox where++import Prelude ()+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 HButtonBox = HButtonBox (ForeignPtr HButtonBox)+instance GObject HButtonBox where+class GObject o => HButtonBoxK o+instance (GObject o, IsDescendantOf HButtonBox o) => HButtonBoxK o
+ GI/Gtk/Objects/HPaned.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.Gtk.Objects.HPaned+    ( ++-- * Exported types+    HPaned(..)                              ,+    HPanedK                                 ,+    toHPaned                                ,+    noHPaned                                ,+++ -- * Methods+-- ** hPanedNew+    hPanedNew                               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HPaned = HPaned (ForeignPtr HPaned)+foreign import ccall "gtk_hpaned_get_type"+    c_gtk_hpaned_get_type :: IO GType++type instance ParentTypes HPaned = HPanedParentTypes+type HPanedParentTypes = '[Paned, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HPaned where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hpaned_get_type+    ++class GObject o => HPanedK o+instance (GObject o, IsDescendantOf HPaned o) => HPanedK o++toHPaned :: HPanedK o => o -> IO HPaned+toHPaned = unsafeCastTo HPaned++noHPaned :: Maybe HPaned+noHPaned = Nothing++type instance AttributeList HPaned = HPanedAttributeList+type HPanedAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-position", PanedMaxPositionPropertyInfo), '("min-position", PanedMinPositionPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("position", PanedPositionPropertyInfo), '("position-set", PanedPositionSetPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("wide-handle", PanedWideHandlePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HPaned = HPanedSignalList+type HPanedSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("accept-position", PanedAcceptPositionSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel-position", PanedCancelPositionSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("cycle-child-focus", PanedCycleChildFocusSignalInfo), '("cycle-handle-focus", PanedCycleHandleFocusSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-handle", PanedMoveHandleSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-handle-focus", PanedToggleHandleFocusSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HPaned::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HPaned"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hpaned_new" gtk_hpaned_new :: +    IO (Ptr HPaned)++{-# DEPRECATED hPanedNew ["(Since version 3.2)","Use gtk_paned_new() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hPanedNew ::+    (MonadIO m) =>+    m HPaned+hPanedNew  = liftIO $ do+    result <- gtk_hpaned_new+    checkUnexpectedReturnNULL "gtk_hpaned_new" result+    result' <- (newObject HPaned) result+    return result'++
+ GI/Gtk/Objects/HPaned.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HPaned where++import Prelude ()+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 HPaned = HPaned (ForeignPtr HPaned)+instance GObject HPaned where+class GObject o => HPanedK o+instance (GObject o, IsDescendantOf HPaned o) => HPanedK o
+ GI/Gtk/Objects/HSV.hs view
@@ -0,0 +1,430 @@++{- |+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.Gtk.Objects.HSV+    ( ++-- * Exported types+    HSV(..)                                 ,+    HSVK                                    ,+    toHSV                                   ,+    noHSV                                   ,+++ -- * Methods+-- ** hSVGetColor+    hSVGetColor                             ,+++-- ** hSVGetMetrics+    hSVGetMetrics                           ,+++-- ** hSVIsAdjusting+    hSVIsAdjusting                          ,+++-- ** hSVNew+    hSVNew                                  ,+++-- ** hSVSetColor+    hSVSetColor                             ,+++-- ** hSVSetMetrics+    hSVSetMetrics                           ,+++-- ** hSVToRgb+    hSVToRgb                                ,+++++ -- * Signals+-- ** Changed+    HSVChangedCallback                      ,+    HSVChangedCallbackC                     ,+    HSVChangedSignalInfo                    ,+    afterHSVChanged                         ,+    hSVChangedCallbackWrapper               ,+    hSVChangedClosure                       ,+    mkHSVChangedCallback                    ,+    noHSVChangedCallback                    ,+    onHSVChanged                            ,+++-- ** Move+    HSVMoveCallback                         ,+    HSVMoveCallbackC                        ,+    HSVMoveSignalInfo                       ,+    afterHSVMove                            ,+    hSVMoveCallbackWrapper                  ,+    hSVMoveClosure                          ,+    mkHSVMoveCallback                       ,+    noHSVMoveCallback                       ,+    onHSVMove                               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HSV = HSV (ForeignPtr HSV)+foreign import ccall "gtk_hsv_get_type"+    c_gtk_hsv_get_type :: IO GType++type instance ParentTypes HSV = HSVParentTypes+type HSVParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject HSV where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hsv_get_type+    ++class GObject o => HSVK o+instance (GObject o, IsDescendantOf HSV o) => HSVK o++toHSV :: HSVK o => o -> IO HSV+toHSV = unsafeCastTo HSV++noHSV :: Maybe HSV+noHSV = Nothing++-- signal HSV::changed+type HSVChangedCallback =+    IO ()++noHSVChangedCallback :: Maybe HSVChangedCallback+noHSVChangedCallback = Nothing++type HSVChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkHSVChangedCallback :: HSVChangedCallbackC -> IO (FunPtr HSVChangedCallbackC)++hSVChangedClosure :: HSVChangedCallback -> IO Closure+hSVChangedClosure cb = newCClosure =<< mkHSVChangedCallback wrapped+    where wrapped = hSVChangedCallbackWrapper cb++hSVChangedCallbackWrapper ::+    HSVChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+hSVChangedCallbackWrapper _cb _ _ = do+    _cb ++onHSVChanged :: (GObject a, MonadIO m) => a -> HSVChangedCallback -> m SignalHandlerId+onHSVChanged obj cb = liftIO $ connectHSVChanged obj cb SignalConnectBefore+afterHSVChanged :: (GObject a, MonadIO m) => a -> HSVChangedCallback -> m SignalHandlerId+afterHSVChanged obj cb = connectHSVChanged obj cb SignalConnectAfter++connectHSVChanged :: (GObject a, MonadIO m) =>+                     a -> HSVChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectHSVChanged obj cb after = liftIO $ do+    cb' <- mkHSVChangedCallback (hSVChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- signal HSV::move+type HSVMoveCallback =+    DirectionType ->+    IO ()++noHSVMoveCallback :: Maybe HSVMoveCallback+noHSVMoveCallback = Nothing++type HSVMoveCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkHSVMoveCallback :: HSVMoveCallbackC -> IO (FunPtr HSVMoveCallbackC)++hSVMoveClosure :: HSVMoveCallback -> IO Closure+hSVMoveClosure cb = newCClosure =<< mkHSVMoveCallback wrapped+    where wrapped = hSVMoveCallbackWrapper cb++hSVMoveCallbackWrapper ::+    HSVMoveCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+hSVMoveCallbackWrapper _cb _ object _ = do+    let object' = (toEnum . fromIntegral) object+    _cb  object'++onHSVMove :: (GObject a, MonadIO m) => a -> HSVMoveCallback -> m SignalHandlerId+onHSVMove obj cb = liftIO $ connectHSVMove obj cb SignalConnectBefore+afterHSVMove :: (GObject a, MonadIO m) => a -> HSVMoveCallback -> m SignalHandlerId+afterHSVMove obj cb = connectHSVMove obj cb SignalConnectAfter++connectHSVMove :: (GObject a, MonadIO m) =>+                  a -> HSVMoveCallback -> SignalConnectMode -> m SignalHandlerId+connectHSVMove obj cb after = liftIO $ do+    cb' <- mkHSVMoveCallback (hSVMoveCallbackWrapper cb)+    connectSignalFunPtr obj "move" cb' after++type instance AttributeList HSV = HSVAttributeList+type HSVAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data HSVChangedSignalInfo+instance SignalInfo HSVChangedSignalInfo where+    type HaskellCallbackType HSVChangedSignalInfo = HSVChangedCallback+    connectSignal _ = connectHSVChanged++data HSVMoveSignalInfo+instance SignalInfo HSVMoveSignalInfo where+    type HaskellCallbackType HSVMoveSignalInfo = HSVMoveCallback+    connectSignal _ = connectHSVMove++type instance SignalList HSV = HSVSignalList+type HSVSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("changed", HSVChangedSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move", HSVMoveSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HSV::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HSV"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_new" gtk_hsv_new :: +    IO (Ptr HSV)+++hSVNew ::+    (MonadIO m) =>+    m HSV+hSVNew  = liftIO $ do+    result <- gtk_hsv_new+    checkUnexpectedReturnNULL "gtk_hsv_new" result+    result' <- (newObject HSV) result+    return result'++-- method HSV::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_get_color" gtk_hsv_get_color :: +    Ptr HSV ->                              -- _obj : TInterface "Gtk" "HSV"+    Ptr CDouble ->                          -- h : TBasicType TDouble+    Ptr CDouble ->                          -- s : TBasicType TDouble+    Ptr CDouble ->                          -- v : TBasicType TDouble+    IO ()+++hSVGetColor ::+    (MonadIO m, HSVK a) =>+    a ->                                    -- _obj+    m (Double,Double,Double)+hSVGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    h <- allocMem :: IO (Ptr CDouble)+    s <- allocMem :: IO (Ptr CDouble)+    v <- allocMem :: IO (Ptr CDouble)+    gtk_hsv_get_color _obj' h s v+    h' <- peek h+    let h'' = realToFrac h'+    s' <- peek s+    let s'' = realToFrac s'+    v' <- peek v+    let v'' = realToFrac v'+    touchManagedPtr _obj+    freeMem h+    freeMem s+    freeMem v+    return (h'', s'', v'')++-- method HSV::get_metrics+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "ring_width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_get_metrics" gtk_hsv_get_metrics :: +    Ptr HSV ->                              -- _obj : TInterface "Gtk" "HSV"+    Ptr Int32 ->                            -- size : TBasicType TInt32+    Ptr Int32 ->                            -- ring_width : TBasicType TInt32+    IO ()+++hSVGetMetrics ::+    (MonadIO m, HSVK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+hSVGetMetrics _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    size <- allocMem :: IO (Ptr Int32)+    ring_width <- allocMem :: IO (Ptr Int32)+    gtk_hsv_get_metrics _obj' size ring_width+    size' <- peek size+    ring_width' <- peek ring_width+    touchManagedPtr _obj+    freeMem size+    freeMem ring_width+    return (size', ring_width')++-- method HSV::is_adjusting+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_is_adjusting" gtk_hsv_is_adjusting :: +    Ptr HSV ->                              -- _obj : TInterface "Gtk" "HSV"+    IO CInt+++hSVIsAdjusting ::+    (MonadIO m, HSVK a) =>+    a ->                                    -- _obj+    m Bool+hSVIsAdjusting _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_hsv_is_adjusting _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method HSV::set_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_set_color" gtk_hsv_set_color :: +    Ptr HSV ->                              -- _obj : TInterface "Gtk" "HSV"+    CDouble ->                              -- h : TBasicType TDouble+    CDouble ->                              -- s : TBasicType TDouble+    CDouble ->                              -- v : TBasicType TDouble+    IO ()+++hSVSetColor ::+    (MonadIO m, HSVK a) =>+    a ->                                    -- _obj+    Double ->                               -- h+    Double ->                               -- s+    Double ->                               -- v+    m ()+hSVSetColor _obj h s v = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let h' = realToFrac h+    let s' = realToFrac s+    let v' = realToFrac v+    gtk_hsv_set_color _obj' h' s' v'+    touchManagedPtr _obj+    return ()++-- method HSV::set_metrics+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", 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 = "ring_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HSV", 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 = "ring_width", 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 "gtk_hsv_set_metrics" gtk_hsv_set_metrics :: +    Ptr HSV ->                              -- _obj : TInterface "Gtk" "HSV"+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- ring_width : TBasicType TInt32+    IO ()+++hSVSetMetrics ::+    (MonadIO m, HSVK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- size+    Int32 ->                                -- ring_width+    m ()+hSVSetMetrics _obj size ring_width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_hsv_set_metrics _obj' size ring_width+    touchManagedPtr _obj+    return ()++-- method HSV::to_rgb+-- method type : MemberFunction+-- Args : [Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "r", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "g", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "b", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "h", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "s", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "v", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hsv_to_rgb" gtk_hsv_to_rgb :: +    CDouble ->                              -- h : TBasicType TDouble+    CDouble ->                              -- s : TBasicType TDouble+    CDouble ->                              -- v : TBasicType TDouble+    Ptr CDouble ->                          -- r : TBasicType TDouble+    Ptr CDouble ->                          -- g : TBasicType TDouble+    Ptr CDouble ->                          -- b : TBasicType TDouble+    IO ()+++hSVToRgb ::+    (MonadIO m) =>+    Double ->                               -- h+    Double ->                               -- s+    Double ->                               -- v+    m (Double,Double,Double)+hSVToRgb h s v = liftIO $ do+    let h' = realToFrac h+    let s' = realToFrac s+    let v' = realToFrac v+    r <- allocMem :: IO (Ptr CDouble)+    g <- allocMem :: IO (Ptr CDouble)+    b <- allocMem :: IO (Ptr CDouble)+    gtk_hsv_to_rgb h' s' v' r g b+    r' <- peek r+    let r'' = realToFrac r'+    g' <- peek g+    let g'' = realToFrac g'+    b' <- peek b+    let b'' = realToFrac b'+    freeMem r+    freeMem g+    freeMem b+    return (r'', g'', b'')++
+ GI/Gtk/Objects/HSV.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.HSV where++import Prelude ()+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 HSV = HSV (ForeignPtr HSV)+instance GObject HSV where+class GObject o => HSVK o+instance (GObject o, IsDescendantOf HSV o) => HSVK o+data HSVChangedSignalInfo+data HSVMoveSignalInfo
+ GI/Gtk/Objects/HScale.hs view
@@ -0,0 +1,131 @@++{- |+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.Gtk.Objects.HScale+    ( ++-- * Exported types+    HScale(..)                              ,+    HScaleK                                 ,+    toHScale                                ,+    noHScale                                ,+++ -- * Methods+-- ** hScaleNew+    hScaleNew                               ,+++-- ** hScaleNewWithRange+    hScaleNewWithRange                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HScale = HScale (ForeignPtr HScale)+foreign import ccall "gtk_hscale_get_type"+    c_gtk_hscale_get_type :: IO GType++type instance ParentTypes HScale = HScaleParentTypes+type HScaleParentTypes = '[Scale, Range, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HScale where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hscale_get_type+    ++class GObject o => HScaleK o+instance (GObject o, IsDescendantOf HScale o) => HScaleK o++toHScale :: HScaleK o => o -> IO HScale+toHScale = unsafeCastTo HScale++noHScale :: Maybe HScale+noHScale = Nothing++type instance AttributeList HScale = HScaleAttributeList+type HScaleAttributeList = ('[ '("adjustment", RangeAdjustmentPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("digits", ScaleDigitsPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-value", ScaleDrawValuePropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("fill-level", RangeFillLevelPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-origin", ScaleHasOriginPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inverted", RangeInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("lower-stepper-sensitivity", RangeLowerStepperSensitivityPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("restrict-to-fill-level", RangeRestrictToFillLevelPropertyInfo), '("round-digits", RangeRoundDigitsPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-fill-level", RangeShowFillLevelPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("upper-stepper-sensitivity", RangeUpperStepperSensitivityPropertyInfo), '("valign", WidgetValignPropertyInfo), '("value-pos", ScaleValuePosPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HScale = HScaleSignalList+type HScaleSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("adjust-bounds", RangeAdjustBoundsSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("change-value", RangeChangeValueSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("format-value", ScaleFormatValueSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-slider", RangeMoveSliderSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("value-changed", RangeValueChangedSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HScale::new+-- method type : Constructor+-- Args : [Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "HScale"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hscale_new" gtk_hscale_new :: +    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO (Ptr HScale)++{-# DEPRECATED hScaleNew ["(Since version 3.2)","Use gtk_scale_new() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hScaleNew ::+    (MonadIO m, AdjustmentK a) =>+    Maybe (a) ->                            -- adjustment+    m HScale+hScaleNew adjustment = liftIO $ do+    maybeAdjustment <- case adjustment of+        Nothing -> return nullPtr+        Just jAdjustment -> do+            let jAdjustment' = unsafeManagedPtrCastPtr jAdjustment+            return jAdjustment'+    result <- gtk_hscale_new maybeAdjustment+    checkUnexpectedReturnNULL "gtk_hscale_new" result+    result' <- (newObject HScale) result+    whenJust adjustment touchManagedPtr+    return result'++-- method HScale::new_with_range+-- method type : Constructor+-- Args : [Arg {argName = "min", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "min", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "HScale"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hscale_new_with_range" gtk_hscale_new_with_range :: +    CDouble ->                              -- min : TBasicType TDouble+    CDouble ->                              -- max : TBasicType TDouble+    CDouble ->                              -- step : TBasicType TDouble+    IO (Ptr HScale)++{-# DEPRECATED hScaleNewWithRange ["(Since version 3.2)","Use gtk_scale_new_with_range() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hScaleNewWithRange ::+    (MonadIO m) =>+    Double ->                               -- min+    Double ->                               -- max+    Double ->                               -- step+    m HScale+hScaleNewWithRange min max step = liftIO $ do+    let min' = realToFrac min+    let max' = realToFrac max+    let step' = realToFrac step+    result <- gtk_hscale_new_with_range min' max' step'+    checkUnexpectedReturnNULL "gtk_hscale_new_with_range" result+    result' <- (newObject HScale) result+    return result'++
+ GI/Gtk/Objects/HScale.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HScale where++import Prelude ()+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 HScale = HScale (ForeignPtr HScale)+instance GObject HScale where+class GObject o => HScaleK o+instance (GObject o, IsDescendantOf HScale o) => HScaleK o
+ GI/Gtk/Objects/HScrollbar.hs view
@@ -0,0 +1,96 @@++{- |+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.Gtk.Objects.HScrollbar+    ( ++-- * Exported types+    HScrollbar(..)                          ,+    HScrollbarK                             ,+    toHScrollbar                            ,+    noHScrollbar                            ,+++ -- * Methods+-- ** hScrollbarNew+    hScrollbarNew                           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HScrollbar = HScrollbar (ForeignPtr HScrollbar)+foreign import ccall "gtk_hscrollbar_get_type"+    c_gtk_hscrollbar_get_type :: IO GType++type instance ParentTypes HScrollbar = HScrollbarParentTypes+type HScrollbarParentTypes = '[Scrollbar, Range, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HScrollbar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hscrollbar_get_type+    ++class GObject o => HScrollbarK o+instance (GObject o, IsDescendantOf HScrollbar o) => HScrollbarK o++toHScrollbar :: HScrollbarK o => o -> IO HScrollbar+toHScrollbar = unsafeCastTo HScrollbar++noHScrollbar :: Maybe HScrollbar+noHScrollbar = Nothing++type instance AttributeList HScrollbar = HScrollbarAttributeList+type HScrollbarAttributeList = ('[ '("adjustment", RangeAdjustmentPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("fill-level", RangeFillLevelPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inverted", RangeInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("lower-stepper-sensitivity", RangeLowerStepperSensitivityPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("restrict-to-fill-level", RangeRestrictToFillLevelPropertyInfo), '("round-digits", RangeRoundDigitsPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-fill-level", RangeShowFillLevelPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("upper-stepper-sensitivity", RangeUpperStepperSensitivityPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HScrollbar = HScrollbarSignalList+type HScrollbarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("adjust-bounds", RangeAdjustBoundsSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("change-value", RangeChangeValueSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-slider", RangeMoveSliderSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("value-changed", RangeValueChangedSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HScrollbar::new+-- method type : Constructor+-- Args : [Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "HScrollbar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hscrollbar_new" gtk_hscrollbar_new :: +    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO (Ptr HScrollbar)++{-# DEPRECATED hScrollbarNew ["(Since version 3.2)","Use gtk_scrollbar_new() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hScrollbarNew ::+    (MonadIO m, AdjustmentK a) =>+    Maybe (a) ->                            -- adjustment+    m HScrollbar+hScrollbarNew adjustment = liftIO $ do+    maybeAdjustment <- case adjustment of+        Nothing -> return nullPtr+        Just jAdjustment -> do+            let jAdjustment' = unsafeManagedPtrCastPtr jAdjustment+            return jAdjustment'+    result <- gtk_hscrollbar_new maybeAdjustment+    checkUnexpectedReturnNULL "gtk_hscrollbar_new" result+    result' <- (newObject HScrollbar) result+    whenJust adjustment touchManagedPtr+    return result'++
+ GI/Gtk/Objects/HScrollbar.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HScrollbar where++import Prelude ()+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 HScrollbar = HScrollbar (ForeignPtr HScrollbar)+instance GObject HScrollbar where+class GObject o => HScrollbarK o+instance (GObject o, IsDescendantOf HScrollbar o) => HScrollbarK o
+ GI/Gtk/Objects/HSeparator.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.Gtk.Objects.HSeparator+    ( ++-- * Exported types+    HSeparator(..)                          ,+    HSeparatorK                             ,+    toHSeparator                            ,+    noHSeparator                            ,+++ -- * Methods+-- ** hSeparatorNew+    hSeparatorNew                           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HSeparator = HSeparator (ForeignPtr HSeparator)+foreign import ccall "gtk_hseparator_get_type"+    c_gtk_hseparator_get_type :: IO GType++type instance ParentTypes HSeparator = HSeparatorParentTypes+type HSeparatorParentTypes = '[Separator, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject HSeparator where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_hseparator_get_type+    ++class GObject o => HSeparatorK o+instance (GObject o, IsDescendantOf HSeparator o) => HSeparatorK o++toHSeparator :: HSeparatorK o => o -> IO HSeparator+toHSeparator = unsafeCastTo HSeparator++noHSeparator :: Maybe HSeparator+noHSeparator = Nothing++type instance AttributeList HSeparator = HSeparatorAttributeList+type HSeparatorAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HSeparator = HSeparatorSignalList+type HSeparatorSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HSeparator::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HSeparator"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_hseparator_new" gtk_hseparator_new :: +    IO (Ptr HSeparator)++{-# DEPRECATED hSeparatorNew ["(Since version 3.2)","Use gtk_separator_new() with %GTK_ORIENTATION_HORIZONTAL instead"]#-}+hSeparatorNew ::+    (MonadIO m) =>+    m HSeparator+hSeparatorNew  = liftIO $ do+    result <- gtk_hseparator_new+    checkUnexpectedReturnNULL "gtk_hseparator_new" result+    result' <- (newObject HSeparator) result+    return result'++
+ GI/Gtk/Objects/HSeparator.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.HSeparator where++import Prelude ()+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 HSeparator = HSeparator (ForeignPtr HSeparator)+instance GObject HSeparator where+class GObject o => HSeparatorK o+instance (GObject o, IsDescendantOf HSeparator o) => HSeparatorK o
+ GI/Gtk/Objects/HandleBox.hs view
@@ -0,0 +1,568 @@++{- |+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.Gtk.Objects.HandleBox+    ( ++-- * Exported types+    HandleBox(..)                           ,+    HandleBoxK                              ,+    toHandleBox                             ,+    noHandleBox                             ,+++ -- * Methods+-- ** handleBoxGetChildDetached+    handleBoxGetChildDetached               ,+++-- ** handleBoxGetHandlePosition+    handleBoxGetHandlePosition              ,+++-- ** handleBoxGetShadowType+    handleBoxGetShadowType                  ,+++-- ** handleBoxGetSnapEdge+    handleBoxGetSnapEdge                    ,+++-- ** handleBoxNew+    handleBoxNew                            ,+++-- ** handleBoxSetHandlePosition+    handleBoxSetHandlePosition              ,+++-- ** handleBoxSetShadowType+    handleBoxSetShadowType                  ,+++-- ** handleBoxSetSnapEdge+    handleBoxSetSnapEdge                    ,+++++ -- * Properties+-- ** ChildDetached+    HandleBoxChildDetachedPropertyInfo      ,+    getHandleBoxChildDetached               ,+++-- ** HandlePosition+    HandleBoxHandlePositionPropertyInfo     ,+    constructHandleBoxHandlePosition        ,+    getHandleBoxHandlePosition              ,+    setHandleBoxHandlePosition              ,+++-- ** ShadowType+    HandleBoxShadowTypePropertyInfo         ,+    constructHandleBoxShadowType            ,+    getHandleBoxShadowType                  ,+    setHandleBoxShadowType                  ,+++-- ** SnapEdge+    HandleBoxSnapEdgePropertyInfo           ,+    constructHandleBoxSnapEdge              ,+    getHandleBoxSnapEdge                    ,+    setHandleBoxSnapEdge                    ,+++-- ** SnapEdgeSet+    HandleBoxSnapEdgeSetPropertyInfo        ,+    constructHandleBoxSnapEdgeSet           ,+    getHandleBoxSnapEdgeSet                 ,+    setHandleBoxSnapEdgeSet                 ,+++++ -- * Signals+-- ** ChildAttached+    HandleBoxChildAttachedCallback          ,+    HandleBoxChildAttachedCallbackC         ,+    HandleBoxChildAttachedSignalInfo        ,+    afterHandleBoxChildAttached             ,+    handleBoxChildAttachedCallbackWrapper   ,+    handleBoxChildAttachedClosure           ,+    mkHandleBoxChildAttachedCallback        ,+    noHandleBoxChildAttachedCallback        ,+    onHandleBoxChildAttached                ,+++-- ** ChildDetached+    HandleBoxChildDetachedCallback          ,+    HandleBoxChildDetachedCallbackC         ,+    HandleBoxChildDetachedSignalInfo        ,+    afterHandleBoxChildDetached             ,+    handleBoxChildDetachedCallbackWrapper   ,+    handleBoxChildDetachedClosure           ,+    mkHandleBoxChildDetachedCallback        ,+    noHandleBoxChildDetachedCallback        ,+    onHandleBoxChildDetached                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HandleBox = HandleBox (ForeignPtr HandleBox)+foreign import ccall "gtk_handle_box_get_type"+    c_gtk_handle_box_get_type :: IO GType++type instance ParentTypes HandleBox = HandleBoxParentTypes+type HandleBoxParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject HandleBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_handle_box_get_type+    ++class GObject o => HandleBoxK o+instance (GObject o, IsDescendantOf HandleBox o) => HandleBoxK o++toHandleBox :: HandleBoxK o => o -> IO HandleBox+toHandleBox = unsafeCastTo HandleBox++noHandleBox :: Maybe HandleBox+noHandleBox = Nothing++-- signal HandleBox::child-attached+type HandleBoxChildAttachedCallback =+    Widget ->+    IO ()++noHandleBoxChildAttachedCallback :: Maybe HandleBoxChildAttachedCallback+noHandleBoxChildAttachedCallback = Nothing++type HandleBoxChildAttachedCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkHandleBoxChildAttachedCallback :: HandleBoxChildAttachedCallbackC -> IO (FunPtr HandleBoxChildAttachedCallbackC)++handleBoxChildAttachedClosure :: HandleBoxChildAttachedCallback -> IO Closure+handleBoxChildAttachedClosure cb = newCClosure =<< mkHandleBoxChildAttachedCallback wrapped+    where wrapped = handleBoxChildAttachedCallbackWrapper cb++handleBoxChildAttachedCallbackWrapper ::+    HandleBoxChildAttachedCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+handleBoxChildAttachedCallbackWrapper _cb _ widget _ = do+    widget' <- (newObject Widget) widget+    _cb  widget'++onHandleBoxChildAttached :: (GObject a, MonadIO m) => a -> HandleBoxChildAttachedCallback -> m SignalHandlerId+onHandleBoxChildAttached obj cb = liftIO $ connectHandleBoxChildAttached obj cb SignalConnectBefore+afterHandleBoxChildAttached :: (GObject a, MonadIO m) => a -> HandleBoxChildAttachedCallback -> m SignalHandlerId+afterHandleBoxChildAttached obj cb = connectHandleBoxChildAttached obj cb SignalConnectAfter++connectHandleBoxChildAttached :: (GObject a, MonadIO m) =>+                                 a -> HandleBoxChildAttachedCallback -> SignalConnectMode -> m SignalHandlerId+connectHandleBoxChildAttached obj cb after = liftIO $ do+    cb' <- mkHandleBoxChildAttachedCallback (handleBoxChildAttachedCallbackWrapper cb)+    connectSignalFunPtr obj "child-attached" cb' after++-- signal HandleBox::child-detached+type HandleBoxChildDetachedCallback =+    Widget ->+    IO ()++noHandleBoxChildDetachedCallback :: Maybe HandleBoxChildDetachedCallback+noHandleBoxChildDetachedCallback = Nothing++type HandleBoxChildDetachedCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkHandleBoxChildDetachedCallback :: HandleBoxChildDetachedCallbackC -> IO (FunPtr HandleBoxChildDetachedCallbackC)++handleBoxChildDetachedClosure :: HandleBoxChildDetachedCallback -> IO Closure+handleBoxChildDetachedClosure cb = newCClosure =<< mkHandleBoxChildDetachedCallback wrapped+    where wrapped = handleBoxChildDetachedCallbackWrapper cb++handleBoxChildDetachedCallbackWrapper ::+    HandleBoxChildDetachedCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+handleBoxChildDetachedCallbackWrapper _cb _ widget _ = do+    widget' <- (newObject Widget) widget+    _cb  widget'++onHandleBoxChildDetached :: (GObject a, MonadIO m) => a -> HandleBoxChildDetachedCallback -> m SignalHandlerId+onHandleBoxChildDetached obj cb = liftIO $ connectHandleBoxChildDetached obj cb SignalConnectBefore+afterHandleBoxChildDetached :: (GObject a, MonadIO m) => a -> HandleBoxChildDetachedCallback -> m SignalHandlerId+afterHandleBoxChildDetached obj cb = connectHandleBoxChildDetached obj cb SignalConnectAfter++connectHandleBoxChildDetached :: (GObject a, MonadIO m) =>+                                 a -> HandleBoxChildDetachedCallback -> SignalConnectMode -> m SignalHandlerId+connectHandleBoxChildDetached obj cb after = liftIO $ do+    cb' <- mkHandleBoxChildDetachedCallback (handleBoxChildDetachedCallbackWrapper cb)+    connectSignalFunPtr obj "child-detached" cb' after++-- VVV Prop "child-detached"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getHandleBoxChildDetached :: (MonadIO m, HandleBoxK o) => o -> m Bool+getHandleBoxChildDetached obj = liftIO $ getObjectPropertyBool obj "child-detached"++data HandleBoxChildDetachedPropertyInfo+instance AttrInfo HandleBoxChildDetachedPropertyInfo where+    type AttrAllowedOps HandleBoxChildDetachedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint HandleBoxChildDetachedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint HandleBoxChildDetachedPropertyInfo = HandleBoxK+    type AttrGetType HandleBoxChildDetachedPropertyInfo = Bool+    type AttrLabel HandleBoxChildDetachedPropertyInfo = "HandleBox::child-detached"+    attrGet _ = getHandleBoxChildDetached+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "handle-position"+   -- Type: TInterface "Gtk" "PositionType"+   -- Flags: [PropertyReadable,PropertyWritable]++getHandleBoxHandlePosition :: (MonadIO m, HandleBoxK o) => o -> m PositionType+getHandleBoxHandlePosition obj = liftIO $ getObjectPropertyEnum obj "handle-position"++setHandleBoxHandlePosition :: (MonadIO m, HandleBoxK o) => o -> PositionType -> m ()+setHandleBoxHandlePosition obj val = liftIO $ setObjectPropertyEnum obj "handle-position" val++constructHandleBoxHandlePosition :: PositionType -> IO ([Char], GValue)+constructHandleBoxHandlePosition val = constructObjectPropertyEnum "handle-position" val++data HandleBoxHandlePositionPropertyInfo+instance AttrInfo HandleBoxHandlePositionPropertyInfo where+    type AttrAllowedOps HandleBoxHandlePositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HandleBoxHandlePositionPropertyInfo = (~) PositionType+    type AttrBaseTypeConstraint HandleBoxHandlePositionPropertyInfo = HandleBoxK+    type AttrGetType HandleBoxHandlePositionPropertyInfo = PositionType+    type AttrLabel HandleBoxHandlePositionPropertyInfo = "HandleBox::handle-position"+    attrGet _ = getHandleBoxHandlePosition+    attrSet _ = setHandleBoxHandlePosition+    attrConstruct _ = constructHandleBoxHandlePosition++-- VVV Prop "shadow-type"+   -- Type: TInterface "Gtk" "ShadowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getHandleBoxShadowType :: (MonadIO m, HandleBoxK o) => o -> m ShadowType+getHandleBoxShadowType obj = liftIO $ getObjectPropertyEnum obj "shadow-type"++setHandleBoxShadowType :: (MonadIO m, HandleBoxK o) => o -> ShadowType -> m ()+setHandleBoxShadowType obj val = liftIO $ setObjectPropertyEnum obj "shadow-type" val++constructHandleBoxShadowType :: ShadowType -> IO ([Char], GValue)+constructHandleBoxShadowType val = constructObjectPropertyEnum "shadow-type" val++data HandleBoxShadowTypePropertyInfo+instance AttrInfo HandleBoxShadowTypePropertyInfo where+    type AttrAllowedOps HandleBoxShadowTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HandleBoxShadowTypePropertyInfo = (~) ShadowType+    type AttrBaseTypeConstraint HandleBoxShadowTypePropertyInfo = HandleBoxK+    type AttrGetType HandleBoxShadowTypePropertyInfo = ShadowType+    type AttrLabel HandleBoxShadowTypePropertyInfo = "HandleBox::shadow-type"+    attrGet _ = getHandleBoxShadowType+    attrSet _ = setHandleBoxShadowType+    attrConstruct _ = constructHandleBoxShadowType++-- VVV Prop "snap-edge"+   -- Type: TInterface "Gtk" "PositionType"+   -- Flags: [PropertyReadable,PropertyWritable]++getHandleBoxSnapEdge :: (MonadIO m, HandleBoxK o) => o -> m PositionType+getHandleBoxSnapEdge obj = liftIO $ getObjectPropertyEnum obj "snap-edge"++setHandleBoxSnapEdge :: (MonadIO m, HandleBoxK o) => o -> PositionType -> m ()+setHandleBoxSnapEdge obj val = liftIO $ setObjectPropertyEnum obj "snap-edge" val++constructHandleBoxSnapEdge :: PositionType -> IO ([Char], GValue)+constructHandleBoxSnapEdge val = constructObjectPropertyEnum "snap-edge" val++data HandleBoxSnapEdgePropertyInfo+instance AttrInfo HandleBoxSnapEdgePropertyInfo where+    type AttrAllowedOps HandleBoxSnapEdgePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HandleBoxSnapEdgePropertyInfo = (~) PositionType+    type AttrBaseTypeConstraint HandleBoxSnapEdgePropertyInfo = HandleBoxK+    type AttrGetType HandleBoxSnapEdgePropertyInfo = PositionType+    type AttrLabel HandleBoxSnapEdgePropertyInfo = "HandleBox::snap-edge"+    attrGet _ = getHandleBoxSnapEdge+    attrSet _ = setHandleBoxSnapEdge+    attrConstruct _ = constructHandleBoxSnapEdge++-- VVV Prop "snap-edge-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getHandleBoxSnapEdgeSet :: (MonadIO m, HandleBoxK o) => o -> m Bool+getHandleBoxSnapEdgeSet obj = liftIO $ getObjectPropertyBool obj "snap-edge-set"++setHandleBoxSnapEdgeSet :: (MonadIO m, HandleBoxK o) => o -> Bool -> m ()+setHandleBoxSnapEdgeSet obj val = liftIO $ setObjectPropertyBool obj "snap-edge-set" val++constructHandleBoxSnapEdgeSet :: Bool -> IO ([Char], GValue)+constructHandleBoxSnapEdgeSet val = constructObjectPropertyBool "snap-edge-set" val++data HandleBoxSnapEdgeSetPropertyInfo+instance AttrInfo HandleBoxSnapEdgeSetPropertyInfo where+    type AttrAllowedOps HandleBoxSnapEdgeSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HandleBoxSnapEdgeSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint HandleBoxSnapEdgeSetPropertyInfo = HandleBoxK+    type AttrGetType HandleBoxSnapEdgeSetPropertyInfo = Bool+    type AttrLabel HandleBoxSnapEdgeSetPropertyInfo = "HandleBox::snap-edge-set"+    attrGet _ = getHandleBoxSnapEdgeSet+    attrSet _ = setHandleBoxSnapEdgeSet+    attrConstruct _ = constructHandleBoxSnapEdgeSet++type instance AttributeList HandleBox = HandleBoxAttributeList+type HandleBoxAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("child-detached", HandleBoxChildDetachedPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("handle-position", HandleBoxHandlePositionPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", HandleBoxShadowTypePropertyInfo), '("snap-edge", HandleBoxSnapEdgePropertyInfo), '("snap-edge-set", HandleBoxSnapEdgeSetPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data HandleBoxChildAttachedSignalInfo+instance SignalInfo HandleBoxChildAttachedSignalInfo where+    type HaskellCallbackType HandleBoxChildAttachedSignalInfo = HandleBoxChildAttachedCallback+    connectSignal _ = connectHandleBoxChildAttached++data HandleBoxChildDetachedSignalInfo+instance SignalInfo HandleBoxChildDetachedSignalInfo where+    type HaskellCallbackType HandleBoxChildDetachedSignalInfo = HandleBoxChildDetachedCallback+    connectSignal _ = connectHandleBoxChildDetached++type instance SignalList HandleBox = HandleBoxSignalList+type HandleBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-attached", HandleBoxChildAttachedSignalInfo), '("child-detached", HandleBoxChildDetachedSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HandleBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HandleBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_new" gtk_handle_box_new :: +    IO (Ptr HandleBox)++{-# DEPRECATED handleBoxNew ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxNew ::+    (MonadIO m) =>+    m HandleBox+handleBoxNew  = liftIO $ do+    result <- gtk_handle_box_new+    checkUnexpectedReturnNULL "gtk_handle_box_new" result+    result' <- (newObject HandleBox) result+    return result'++-- method HandleBox::get_child_detached+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_get_child_detached" gtk_handle_box_get_child_detached :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    IO CInt++{-# DEPRECATED handleBoxGetChildDetached ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxGetChildDetached ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    m Bool+handleBoxGetChildDetached _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_handle_box_get_child_detached _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method HandleBox::get_handle_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PositionType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_get_handle_position" gtk_handle_box_get_handle_position :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    IO CUInt++{-# DEPRECATED handleBoxGetHandlePosition ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxGetHandlePosition ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    m PositionType+handleBoxGetHandlePosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_handle_box_get_handle_position _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method HandleBox::get_shadow_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ShadowType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_get_shadow_type" gtk_handle_box_get_shadow_type :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    IO CUInt++{-# DEPRECATED handleBoxGetShadowType ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxGetShadowType ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    m ShadowType+handleBoxGetShadowType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_handle_box_get_shadow_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method HandleBox::get_snap_edge+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PositionType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_get_snap_edge" gtk_handle_box_get_snap_edge :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    IO CUInt++{-# DEPRECATED handleBoxGetSnapEdge ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxGetSnapEdge ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    m PositionType+handleBoxGetSnapEdge _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_handle_box_get_snap_edge _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method HandleBox::set_handle_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_set_handle_position" gtk_handle_box_set_handle_position :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    CUInt ->                                -- position : TInterface "Gtk" "PositionType"+    IO ()++{-# DEPRECATED handleBoxSetHandlePosition ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxSetHandlePosition ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    PositionType ->                         -- position+    m ()+handleBoxSetHandlePosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let position' = (fromIntegral . fromEnum) position+    gtk_handle_box_set_handle_position _obj' position'+    touchManagedPtr _obj+    return ()++-- method HandleBox::set_shadow_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "type", argType = TInterface "Gtk" "ShadowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_set_shadow_type" gtk_handle_box_set_shadow_type :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    CUInt ->                                -- type : TInterface "Gtk" "ShadowType"+    IO ()++{-# DEPRECATED handleBoxSetShadowType ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxSetShadowType ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    ShadowType ->                           -- type+    m ()+handleBoxSetShadowType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = (fromIntegral . fromEnum) type_+    gtk_handle_box_set_shadow_type _obj' type_'+    touchManagedPtr _obj+    return ()++-- method HandleBox::set_snap_edge+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edge", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HandleBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "edge", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_handle_box_set_snap_edge" gtk_handle_box_set_snap_edge :: +    Ptr HandleBox ->                        -- _obj : TInterface "Gtk" "HandleBox"+    CUInt ->                                -- edge : TInterface "Gtk" "PositionType"+    IO ()++{-# DEPRECATED handleBoxSetSnapEdge ["(Since version 3.4)","#GtkHandleBox has been deprecated."]#-}+handleBoxSetSnapEdge ::+    (MonadIO m, HandleBoxK a) =>+    a ->                                    -- _obj+    PositionType ->                         -- edge+    m ()+handleBoxSetSnapEdge _obj edge = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let edge' = (fromIntegral . fromEnum) edge+    gtk_handle_box_set_snap_edge _obj' edge'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/HandleBox.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gtk.Objects.HandleBox where++import Prelude ()+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 HandleBox = HandleBox (ForeignPtr HandleBox)+instance GObject HandleBox where+class GObject o => HandleBoxK o+instance (GObject o, IsDescendantOf HandleBox o) => HandleBoxK o+data HandleBoxChildDetachedPropertyInfo+data HandleBoxHandlePositionPropertyInfo+data HandleBoxShadowTypePropertyInfo+data HandleBoxSnapEdgePropertyInfo+data HandleBoxSnapEdgeSetPropertyInfo+data HandleBoxChildAttachedSignalInfo+data HandleBoxChildDetachedSignalInfo
+ GI/Gtk/Objects/HeaderBar.hs view
@@ -0,0 +1,787 @@++{- |+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.Gtk.Objects.HeaderBar+    ( ++-- * Exported types+    HeaderBar(..)                           ,+    HeaderBarK                              ,+    toHeaderBar                             ,+    noHeaderBar                             ,+++ -- * Methods+-- ** headerBarGetCustomTitle+    headerBarGetCustomTitle                 ,+++-- ** headerBarGetDecorationLayout+    headerBarGetDecorationLayout            ,+++-- ** headerBarGetHasSubtitle+    headerBarGetHasSubtitle                 ,+++-- ** headerBarGetShowCloseButton+    headerBarGetShowCloseButton             ,+++-- ** headerBarGetSubtitle+    headerBarGetSubtitle                    ,+++-- ** headerBarGetTitle+    headerBarGetTitle                       ,+++-- ** headerBarNew+    headerBarNew                            ,+++-- ** headerBarPackEnd+    headerBarPackEnd                        ,+++-- ** headerBarPackStart+    headerBarPackStart                      ,+++-- ** headerBarSetCustomTitle+    headerBarSetCustomTitle                 ,+++-- ** headerBarSetDecorationLayout+    headerBarSetDecorationLayout            ,+++-- ** headerBarSetHasSubtitle+    headerBarSetHasSubtitle                 ,+++-- ** headerBarSetShowCloseButton+    headerBarSetShowCloseButton             ,+++-- ** headerBarSetSubtitle+    headerBarSetSubtitle                    ,+++-- ** headerBarSetTitle+    headerBarSetTitle                       ,+++++ -- * Properties+-- ** CustomTitle+    HeaderBarCustomTitlePropertyInfo        ,+    constructHeaderBarCustomTitle           ,+    getHeaderBarCustomTitle                 ,+    setHeaderBarCustomTitle                 ,+++-- ** DecorationLayout+    HeaderBarDecorationLayoutPropertyInfo   ,+    constructHeaderBarDecorationLayout      ,+    getHeaderBarDecorationLayout            ,+    setHeaderBarDecorationLayout            ,+++-- ** DecorationLayoutSet+    HeaderBarDecorationLayoutSetPropertyInfo,+    constructHeaderBarDecorationLayoutSet   ,+    getHeaderBarDecorationLayoutSet         ,+    setHeaderBarDecorationLayoutSet         ,+++-- ** HasSubtitle+    HeaderBarHasSubtitlePropertyInfo        ,+    constructHeaderBarHasSubtitle           ,+    getHeaderBarHasSubtitle                 ,+    setHeaderBarHasSubtitle                 ,+++-- ** ShowCloseButton+    HeaderBarShowCloseButtonPropertyInfo    ,+    constructHeaderBarShowCloseButton       ,+    getHeaderBarShowCloseButton             ,+    setHeaderBarShowCloseButton             ,+++-- ** Spacing+    HeaderBarSpacingPropertyInfo            ,+    constructHeaderBarSpacing               ,+    getHeaderBarSpacing                     ,+    setHeaderBarSpacing                     ,+++-- ** Subtitle+    HeaderBarSubtitlePropertyInfo           ,+    constructHeaderBarSubtitle              ,+    getHeaderBarSubtitle                    ,+    setHeaderBarSubtitle                    ,+++-- ** Title+    HeaderBarTitlePropertyInfo              ,+    constructHeaderBarTitle                 ,+    getHeaderBarTitle                       ,+    setHeaderBarTitle                       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype HeaderBar = HeaderBar (ForeignPtr HeaderBar)+foreign import ccall "gtk_header_bar_get_type"+    c_gtk_header_bar_get_type :: IO GType++type instance ParentTypes HeaderBar = HeaderBarParentTypes+type HeaderBarParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject HeaderBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_header_bar_get_type+    ++class GObject o => HeaderBarK o+instance (GObject o, IsDescendantOf HeaderBar o) => HeaderBarK o++toHeaderBar :: HeaderBarK o => o -> IO HeaderBar+toHeaderBar = unsafeCastTo HeaderBar++noHeaderBar :: Maybe HeaderBar+noHeaderBar = Nothing++-- VVV Prop "custom-title"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarCustomTitle :: (MonadIO m, HeaderBarK o) => o -> m Widget+getHeaderBarCustomTitle obj = liftIO $ getObjectPropertyObject obj "custom-title" Widget++setHeaderBarCustomTitle :: (MonadIO m, HeaderBarK o, WidgetK a) => o -> a -> m ()+setHeaderBarCustomTitle obj val = liftIO $ setObjectPropertyObject obj "custom-title" val++constructHeaderBarCustomTitle :: (WidgetK a) => a -> IO ([Char], GValue)+constructHeaderBarCustomTitle val = constructObjectPropertyObject "custom-title" val++data HeaderBarCustomTitlePropertyInfo+instance AttrInfo HeaderBarCustomTitlePropertyInfo where+    type AttrAllowedOps HeaderBarCustomTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarCustomTitlePropertyInfo = WidgetK+    type AttrBaseTypeConstraint HeaderBarCustomTitlePropertyInfo = HeaderBarK+    type AttrGetType HeaderBarCustomTitlePropertyInfo = Widget+    type AttrLabel HeaderBarCustomTitlePropertyInfo = "HeaderBar::custom-title"+    attrGet _ = getHeaderBarCustomTitle+    attrSet _ = setHeaderBarCustomTitle+    attrConstruct _ = constructHeaderBarCustomTitle++-- VVV Prop "decoration-layout"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarDecorationLayout :: (MonadIO m, HeaderBarK o) => o -> m T.Text+getHeaderBarDecorationLayout obj = liftIO $ getObjectPropertyString obj "decoration-layout"++setHeaderBarDecorationLayout :: (MonadIO m, HeaderBarK o) => o -> T.Text -> m ()+setHeaderBarDecorationLayout obj val = liftIO $ setObjectPropertyString obj "decoration-layout" val++constructHeaderBarDecorationLayout :: T.Text -> IO ([Char], GValue)+constructHeaderBarDecorationLayout val = constructObjectPropertyString "decoration-layout" val++data HeaderBarDecorationLayoutPropertyInfo+instance AttrInfo HeaderBarDecorationLayoutPropertyInfo where+    type AttrAllowedOps HeaderBarDecorationLayoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarDecorationLayoutPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint HeaderBarDecorationLayoutPropertyInfo = HeaderBarK+    type AttrGetType HeaderBarDecorationLayoutPropertyInfo = T.Text+    type AttrLabel HeaderBarDecorationLayoutPropertyInfo = "HeaderBar::decoration-layout"+    attrGet _ = getHeaderBarDecorationLayout+    attrSet _ = setHeaderBarDecorationLayout+    attrConstruct _ = constructHeaderBarDecorationLayout++-- VVV Prop "decoration-layout-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarDecorationLayoutSet :: (MonadIO m, HeaderBarK o) => o -> m Bool+getHeaderBarDecorationLayoutSet obj = liftIO $ getObjectPropertyBool obj "decoration-layout-set"++setHeaderBarDecorationLayoutSet :: (MonadIO m, HeaderBarK o) => o -> Bool -> m ()+setHeaderBarDecorationLayoutSet obj val = liftIO $ setObjectPropertyBool obj "decoration-layout-set" val++constructHeaderBarDecorationLayoutSet :: Bool -> IO ([Char], GValue)+constructHeaderBarDecorationLayoutSet val = constructObjectPropertyBool "decoration-layout-set" val++data HeaderBarDecorationLayoutSetPropertyInfo+instance AttrInfo HeaderBarDecorationLayoutSetPropertyInfo where+    type AttrAllowedOps HeaderBarDecorationLayoutSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarDecorationLayoutSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint HeaderBarDecorationLayoutSetPropertyInfo = HeaderBarK+    type AttrGetType HeaderBarDecorationLayoutSetPropertyInfo = Bool+    type AttrLabel HeaderBarDecorationLayoutSetPropertyInfo = "HeaderBar::decoration-layout-set"+    attrGet _ = getHeaderBarDecorationLayoutSet+    attrSet _ = setHeaderBarDecorationLayoutSet+    attrConstruct _ = constructHeaderBarDecorationLayoutSet++-- VVV Prop "has-subtitle"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarHasSubtitle :: (MonadIO m, HeaderBarK o) => o -> m Bool+getHeaderBarHasSubtitle obj = liftIO $ getObjectPropertyBool obj "has-subtitle"++setHeaderBarHasSubtitle :: (MonadIO m, HeaderBarK o) => o -> Bool -> m ()+setHeaderBarHasSubtitle obj val = liftIO $ setObjectPropertyBool obj "has-subtitle" val++constructHeaderBarHasSubtitle :: Bool -> IO ([Char], GValue)+constructHeaderBarHasSubtitle val = constructObjectPropertyBool "has-subtitle" val++data HeaderBarHasSubtitlePropertyInfo+instance AttrInfo HeaderBarHasSubtitlePropertyInfo where+    type AttrAllowedOps HeaderBarHasSubtitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarHasSubtitlePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint HeaderBarHasSubtitlePropertyInfo = HeaderBarK+    type AttrGetType HeaderBarHasSubtitlePropertyInfo = Bool+    type AttrLabel HeaderBarHasSubtitlePropertyInfo = "HeaderBar::has-subtitle"+    attrGet _ = getHeaderBarHasSubtitle+    attrSet _ = setHeaderBarHasSubtitle+    attrConstruct _ = constructHeaderBarHasSubtitle++-- VVV Prop "show-close-button"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarShowCloseButton :: (MonadIO m, HeaderBarK o) => o -> m Bool+getHeaderBarShowCloseButton obj = liftIO $ getObjectPropertyBool obj "show-close-button"++setHeaderBarShowCloseButton :: (MonadIO m, HeaderBarK o) => o -> Bool -> m ()+setHeaderBarShowCloseButton obj val = liftIO $ setObjectPropertyBool obj "show-close-button" val++constructHeaderBarShowCloseButton :: Bool -> IO ([Char], GValue)+constructHeaderBarShowCloseButton val = constructObjectPropertyBool "show-close-button" val++data HeaderBarShowCloseButtonPropertyInfo+instance AttrInfo HeaderBarShowCloseButtonPropertyInfo where+    type AttrAllowedOps HeaderBarShowCloseButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarShowCloseButtonPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint HeaderBarShowCloseButtonPropertyInfo = HeaderBarK+    type AttrGetType HeaderBarShowCloseButtonPropertyInfo = Bool+    type AttrLabel HeaderBarShowCloseButtonPropertyInfo = "HeaderBar::show-close-button"+    attrGet _ = getHeaderBarShowCloseButton+    attrSet _ = setHeaderBarShowCloseButton+    attrConstruct _ = constructHeaderBarShowCloseButton++-- VVV Prop "spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarSpacing :: (MonadIO m, HeaderBarK o) => o -> m Int32+getHeaderBarSpacing obj = liftIO $ getObjectPropertyCInt obj "spacing"++setHeaderBarSpacing :: (MonadIO m, HeaderBarK o) => o -> Int32 -> m ()+setHeaderBarSpacing obj val = liftIO $ setObjectPropertyCInt obj "spacing" val++constructHeaderBarSpacing :: Int32 -> IO ([Char], GValue)+constructHeaderBarSpacing val = constructObjectPropertyCInt "spacing" val++data HeaderBarSpacingPropertyInfo+instance AttrInfo HeaderBarSpacingPropertyInfo where+    type AttrAllowedOps HeaderBarSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint HeaderBarSpacingPropertyInfo = HeaderBarK+    type AttrGetType HeaderBarSpacingPropertyInfo = Int32+    type AttrLabel HeaderBarSpacingPropertyInfo = "HeaderBar::spacing"+    attrGet _ = getHeaderBarSpacing+    attrSet _ = setHeaderBarSpacing+    attrConstruct _ = constructHeaderBarSpacing++-- VVV Prop "subtitle"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarSubtitle :: (MonadIO m, HeaderBarK o) => o -> m T.Text+getHeaderBarSubtitle obj = liftIO $ getObjectPropertyString obj "subtitle"++setHeaderBarSubtitle :: (MonadIO m, HeaderBarK o) => o -> T.Text -> m ()+setHeaderBarSubtitle obj val = liftIO $ setObjectPropertyString obj "subtitle" val++constructHeaderBarSubtitle :: T.Text -> IO ([Char], GValue)+constructHeaderBarSubtitle val = constructObjectPropertyString "subtitle" val++data HeaderBarSubtitlePropertyInfo+instance AttrInfo HeaderBarSubtitlePropertyInfo where+    type AttrAllowedOps HeaderBarSubtitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarSubtitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint HeaderBarSubtitlePropertyInfo = HeaderBarK+    type AttrGetType HeaderBarSubtitlePropertyInfo = T.Text+    type AttrLabel HeaderBarSubtitlePropertyInfo = "HeaderBar::subtitle"+    attrGet _ = getHeaderBarSubtitle+    attrSet _ = setHeaderBarSubtitle+    attrConstruct _ = constructHeaderBarSubtitle++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getHeaderBarTitle :: (MonadIO m, HeaderBarK o) => o -> m T.Text+getHeaderBarTitle obj = liftIO $ getObjectPropertyString obj "title"++setHeaderBarTitle :: (MonadIO m, HeaderBarK o) => o -> T.Text -> m ()+setHeaderBarTitle obj val = liftIO $ setObjectPropertyString obj "title" val++constructHeaderBarTitle :: T.Text -> IO ([Char], GValue)+constructHeaderBarTitle val = constructObjectPropertyString "title" val++data HeaderBarTitlePropertyInfo+instance AttrInfo HeaderBarTitlePropertyInfo where+    type AttrAllowedOps HeaderBarTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint HeaderBarTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint HeaderBarTitlePropertyInfo = HeaderBarK+    type AttrGetType HeaderBarTitlePropertyInfo = T.Text+    type AttrLabel HeaderBarTitlePropertyInfo = "HeaderBar::title"+    attrGet _ = getHeaderBarTitle+    attrSet _ = setHeaderBarTitle+    attrConstruct _ = constructHeaderBarTitle++type instance AttributeList HeaderBar = HeaderBarAttributeList+type HeaderBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("custom-title", HeaderBarCustomTitlePropertyInfo), '("decoration-layout", HeaderBarDecorationLayoutPropertyInfo), '("decoration-layout-set", HeaderBarDecorationLayoutSetPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-subtitle", HeaderBarHasSubtitlePropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-close-button", HeaderBarShowCloseButtonPropertyInfo), '("spacing", HeaderBarSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("subtitle", HeaderBarSubtitlePropertyInfo), '("title", HeaderBarTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList HeaderBar = HeaderBarSignalList+type HeaderBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method HeaderBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "HeaderBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_new" gtk_header_bar_new :: +    IO (Ptr HeaderBar)+++headerBarNew ::+    (MonadIO m) =>+    m HeaderBar+headerBarNew  = liftIO $ do+    result <- gtk_header_bar_new+    checkUnexpectedReturnNULL "gtk_header_bar_new" result+    result' <- (newObject HeaderBar) result+    return result'++-- method HeaderBar::get_custom_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_custom_title" gtk_header_bar_get_custom_title :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO (Ptr Widget)+++headerBarGetCustomTitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m Widget+headerBarGetCustomTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_custom_title _obj'+    checkUnexpectedReturnNULL "gtk_header_bar_get_custom_title" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::get_decoration_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_decoration_layout" gtk_header_bar_get_decoration_layout :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO CString+++headerBarGetDecorationLayout ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m T.Text+headerBarGetDecorationLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_decoration_layout _obj'+    checkUnexpectedReturnNULL "gtk_header_bar_get_decoration_layout" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::get_has_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_has_subtitle" gtk_header_bar_get_has_subtitle :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO CInt+++headerBarGetHasSubtitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m Bool+headerBarGetHasSubtitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_has_subtitle _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::get_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_show_close_button" gtk_header_bar_get_show_close_button :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO CInt+++headerBarGetShowCloseButton ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m Bool+headerBarGetShowCloseButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_show_close_button _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::get_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_subtitle" gtk_header_bar_get_subtitle :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO CString+++headerBarGetSubtitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m T.Text+headerBarGetSubtitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_subtitle _obj'+    checkUnexpectedReturnNULL "gtk_header_bar_get_subtitle" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_get_title" gtk_header_bar_get_title :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    IO CString+++headerBarGetTitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    m T.Text+headerBarGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_header_bar_get_title _obj'+    checkUnexpectedReturnNULL "gtk_header_bar_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method HeaderBar::pack_end+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_pack_end" gtk_header_bar_pack_end :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++headerBarPackEnd ::+    (MonadIO m, HeaderBarK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+headerBarPackEnd _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_header_bar_pack_end _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method HeaderBar::pack_start+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_pack_start" gtk_header_bar_pack_start :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++headerBarPackStart ::+    (MonadIO m, HeaderBarK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+headerBarPackStart _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_header_bar_pack_start _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method HeaderBar::set_custom_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_header_bar_set_custom_title" gtk_header_bar_set_custom_title :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    Ptr Widget ->                           -- title_widget : TInterface "Gtk" "Widget"+    IO ()+++headerBarSetCustomTitle ::+    (MonadIO m, HeaderBarK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- title_widget+    m ()+headerBarSetCustomTitle _obj title_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTitle_widget <- case title_widget of+        Nothing -> return nullPtr+        Just jTitle_widget -> do+            let jTitle_widget' = unsafeManagedPtrCastPtr jTitle_widget+            return jTitle_widget'+    gtk_header_bar_set_custom_title _obj' maybeTitle_widget+    touchManagedPtr _obj+    whenJust title_widget touchManagedPtr+    return ()++-- method HeaderBar::set_decoration_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "layout", 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 "gtk_header_bar_set_decoration_layout" gtk_header_bar_set_decoration_layout :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    CString ->                              -- layout : TBasicType TUTF8+    IO ()+++headerBarSetDecorationLayout ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- layout+    m ()+headerBarSetDecorationLayout _obj layout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLayout <- case layout of+        Nothing -> return nullPtr+        Just jLayout -> do+            jLayout' <- textToCString jLayout+            return jLayout'+    gtk_header_bar_set_decoration_layout _obj' maybeLayout+    touchManagedPtr _obj+    freeMem maybeLayout+    return ()++-- method HeaderBar::set_has_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_header_bar_set_has_subtitle" gtk_header_bar_set_has_subtitle :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++headerBarSetHasSubtitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+headerBarSetHasSubtitle _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_header_bar_set_has_subtitle _obj' setting'+    touchManagedPtr _obj+    return ()++-- method HeaderBar::set_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_header_bar_set_show_close_button" gtk_header_bar_set_show_close_button :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++headerBarSetShowCloseButton ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+headerBarSetShowCloseButton _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_header_bar_set_show_close_button _obj' setting'+    touchManagedPtr _obj+    return ()++-- method HeaderBar::set_subtitle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subtitle", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "subtitle", 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 "gtk_header_bar_set_subtitle" gtk_header_bar_set_subtitle :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    CString ->                              -- subtitle : TBasicType TUTF8+    IO ()+++headerBarSetSubtitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- subtitle+    m ()+headerBarSetSubtitle _obj subtitle = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSubtitle <- case subtitle of+        Nothing -> return nullPtr+        Just jSubtitle -> do+            jSubtitle' <- textToCString jSubtitle+            return jSubtitle'+    gtk_header_bar_set_subtitle _obj' maybeSubtitle+    touchManagedPtr _obj+    freeMem maybeSubtitle+    return ()++-- method HeaderBar::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "HeaderBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "title", 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 "gtk_header_bar_set_title" gtk_header_bar_set_title :: +    Ptr HeaderBar ->                        -- _obj : TInterface "Gtk" "HeaderBar"+    CString ->                              -- title : TBasicType TUTF8+    IO ()+++headerBarSetTitle ::+    (MonadIO m, HeaderBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- title+    m ()+headerBarSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTitle <- case title of+        Nothing -> return nullPtr+        Just jTitle -> do+            jTitle' <- textToCString jTitle+            return jTitle'+    gtk_header_bar_set_title _obj' maybeTitle+    touchManagedPtr _obj+    freeMem maybeTitle+    return ()++
+ GI/Gtk/Objects/HeaderBar.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.HeaderBar where++import Prelude ()+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 HeaderBar = HeaderBar (ForeignPtr HeaderBar)+instance GObject HeaderBar where+class GObject o => HeaderBarK o+instance (GObject o, IsDescendantOf HeaderBar o) => HeaderBarK o+data HeaderBarCustomTitlePropertyInfo+data HeaderBarDecorationLayoutPropertyInfo+data HeaderBarDecorationLayoutSetPropertyInfo+data HeaderBarHasSubtitlePropertyInfo+data HeaderBarShowCloseButtonPropertyInfo+data HeaderBarSpacingPropertyInfo+data HeaderBarSubtitlePropertyInfo+data HeaderBarTitlePropertyInfo
+ GI/Gtk/Objects/IMContext.hs view
@@ -0,0 +1,842 @@++{- |+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.Gtk.Objects.IMContext+    ( ++-- * Exported types+    IMContext(..)                           ,+    IMContextK                              ,+    toIMContext                             ,+    noIMContext                             ,+++ -- * Methods+-- ** iMContextDeleteSurrounding+    iMContextDeleteSurrounding              ,+++-- ** iMContextFilterKeypress+    iMContextFilterKeypress                 ,+++-- ** iMContextFocusIn+    iMContextFocusIn                        ,+++-- ** iMContextFocusOut+    iMContextFocusOut                       ,+++-- ** iMContextGetPreeditString+    iMContextGetPreeditString               ,+++-- ** iMContextGetSurrounding+    iMContextGetSurrounding                 ,+++-- ** iMContextReset+    iMContextReset                          ,+++-- ** iMContextSetClientWindow+    iMContextSetClientWindow                ,+++-- ** iMContextSetCursorLocation+    iMContextSetCursorLocation              ,+++-- ** iMContextSetSurrounding+    iMContextSetSurrounding                 ,+++-- ** iMContextSetUsePreedit+    iMContextSetUsePreedit                  ,+++++ -- * Properties+-- ** InputHints+    IMContextInputHintsPropertyInfo         ,+    constructIMContextInputHints            ,+    getIMContextInputHints                  ,+    setIMContextInputHints                  ,+++-- ** InputPurpose+    IMContextInputPurposePropertyInfo       ,+    constructIMContextInputPurpose          ,+    getIMContextInputPurpose                ,+    setIMContextInputPurpose                ,+++++ -- * Signals+-- ** Commit+    IMContextCommitCallback                 ,+    IMContextCommitCallbackC                ,+    IMContextCommitSignalInfo               ,+    afterIMContextCommit                    ,+    iMContextCommitCallbackWrapper          ,+    iMContextCommitClosure                  ,+    mkIMContextCommitCallback               ,+    noIMContextCommitCallback               ,+    onIMContextCommit                       ,+++-- ** DeleteSurrounding+    IMContextDeleteSurroundingCallback      ,+    IMContextDeleteSurroundingCallbackC     ,+    IMContextDeleteSurroundingSignalInfo    ,+    afterIMContextDeleteSurrounding         ,+    iMContextDeleteSurroundingCallbackWrapper,+    iMContextDeleteSurroundingClosure       ,+    mkIMContextDeleteSurroundingCallback    ,+    noIMContextDeleteSurroundingCallback    ,+    onIMContextDeleteSurrounding            ,+++-- ** PreeditChanged+    IMContextPreeditChangedCallback         ,+    IMContextPreeditChangedCallbackC        ,+    IMContextPreeditChangedSignalInfo       ,+    afterIMContextPreeditChanged            ,+    iMContextPreeditChangedCallbackWrapper  ,+    iMContextPreeditChangedClosure          ,+    mkIMContextPreeditChangedCallback       ,+    noIMContextPreeditChangedCallback       ,+    onIMContextPreeditChanged               ,+++-- ** PreeditEnd+    IMContextPreeditEndCallback             ,+    IMContextPreeditEndCallbackC            ,+    IMContextPreeditEndSignalInfo           ,+    afterIMContextPreeditEnd                ,+    iMContextPreeditEndCallbackWrapper      ,+    iMContextPreeditEndClosure              ,+    mkIMContextPreeditEndCallback           ,+    noIMContextPreeditEndCallback           ,+    onIMContextPreeditEnd                   ,+++-- ** PreeditStart+    IMContextPreeditStartCallback           ,+    IMContextPreeditStartCallbackC          ,+    IMContextPreeditStartSignalInfo         ,+    afterIMContextPreeditStart              ,+    iMContextPreeditStartCallbackWrapper    ,+    iMContextPreeditStartClosure            ,+    mkIMContextPreeditStartCallback         ,+    noIMContextPreeditStartCallback         ,+    onIMContextPreeditStart                 ,+++-- ** RetrieveSurrounding+    IMContextRetrieveSurroundingCallback    ,+    IMContextRetrieveSurroundingCallbackC   ,+    IMContextRetrieveSurroundingSignalInfo  ,+    afterIMContextRetrieveSurrounding       ,+    iMContextRetrieveSurroundingCallbackWrapper,+    iMContextRetrieveSurroundingClosure     ,+    mkIMContextRetrieveSurroundingCallback  ,+    noIMContextRetrieveSurroundingCallback  ,+    onIMContextRetrieveSurrounding          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Pango as Pango++newtype IMContext = IMContext (ForeignPtr IMContext)+foreign import ccall "gtk_im_context_get_type"+    c_gtk_im_context_get_type :: IO GType++type instance ParentTypes IMContext = IMContextParentTypes+type IMContextParentTypes = '[GObject.Object]++instance GObject IMContext where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_im_context_get_type+    ++class GObject o => IMContextK o+instance (GObject o, IsDescendantOf IMContext o) => IMContextK o++toIMContext :: IMContextK o => o -> IO IMContext+toIMContext = unsafeCastTo IMContext++noIMContext :: Maybe IMContext+noIMContext = Nothing++-- signal IMContext::commit+type IMContextCommitCallback =+    T.Text ->+    IO ()++noIMContextCommitCallback :: Maybe IMContextCommitCallback+noIMContextCommitCallback = Nothing++type IMContextCommitCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIMContextCommitCallback :: IMContextCommitCallbackC -> IO (FunPtr IMContextCommitCallbackC)++iMContextCommitClosure :: IMContextCommitCallback -> IO Closure+iMContextCommitClosure cb = newCClosure =<< mkIMContextCommitCallback wrapped+    where wrapped = iMContextCommitCallbackWrapper cb++iMContextCommitCallbackWrapper ::+    IMContextCommitCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+iMContextCommitCallbackWrapper _cb _ str _ = do+    str' <- cstringToText str+    _cb  str'++onIMContextCommit :: (GObject a, MonadIO m) => a -> IMContextCommitCallback -> m SignalHandlerId+onIMContextCommit obj cb = liftIO $ connectIMContextCommit obj cb SignalConnectBefore+afterIMContextCommit :: (GObject a, MonadIO m) => a -> IMContextCommitCallback -> m SignalHandlerId+afterIMContextCommit obj cb = connectIMContextCommit obj cb SignalConnectAfter++connectIMContextCommit :: (GObject a, MonadIO m) =>+                          a -> IMContextCommitCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextCommit obj cb after = liftIO $ do+    cb' <- mkIMContextCommitCallback (iMContextCommitCallbackWrapper cb)+    connectSignalFunPtr obj "commit" cb' after++-- signal IMContext::delete-surrounding+type IMContextDeleteSurroundingCallback =+    Int32 ->+    Int32 ->+    IO Bool++noIMContextDeleteSurroundingCallback :: Maybe IMContextDeleteSurroundingCallback+noIMContextDeleteSurroundingCallback = Nothing++type IMContextDeleteSurroundingCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkIMContextDeleteSurroundingCallback :: IMContextDeleteSurroundingCallbackC -> IO (FunPtr IMContextDeleteSurroundingCallbackC)++iMContextDeleteSurroundingClosure :: IMContextDeleteSurroundingCallback -> IO Closure+iMContextDeleteSurroundingClosure cb = newCClosure =<< mkIMContextDeleteSurroundingCallback wrapped+    where wrapped = iMContextDeleteSurroundingCallbackWrapper cb++iMContextDeleteSurroundingCallbackWrapper ::+    IMContextDeleteSurroundingCallback ->+    Ptr () ->+    Int32 ->+    Int32 ->+    Ptr () ->+    IO CInt+iMContextDeleteSurroundingCallbackWrapper _cb _ offset n_chars _ = do+    result <- _cb  offset n_chars+    let result' = (fromIntegral . fromEnum) result+    return result'++onIMContextDeleteSurrounding :: (GObject a, MonadIO m) => a -> IMContextDeleteSurroundingCallback -> m SignalHandlerId+onIMContextDeleteSurrounding obj cb = liftIO $ connectIMContextDeleteSurrounding obj cb SignalConnectBefore+afterIMContextDeleteSurrounding :: (GObject a, MonadIO m) => a -> IMContextDeleteSurroundingCallback -> m SignalHandlerId+afterIMContextDeleteSurrounding obj cb = connectIMContextDeleteSurrounding obj cb SignalConnectAfter++connectIMContextDeleteSurrounding :: (GObject a, MonadIO m) =>+                                     a -> IMContextDeleteSurroundingCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextDeleteSurrounding obj cb after = liftIO $ do+    cb' <- mkIMContextDeleteSurroundingCallback (iMContextDeleteSurroundingCallbackWrapper cb)+    connectSignalFunPtr obj "delete-surrounding" cb' after++-- signal IMContext::preedit-changed+type IMContextPreeditChangedCallback =+    IO ()++noIMContextPreeditChangedCallback :: Maybe IMContextPreeditChangedCallback+noIMContextPreeditChangedCallback = Nothing++type IMContextPreeditChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIMContextPreeditChangedCallback :: IMContextPreeditChangedCallbackC -> IO (FunPtr IMContextPreeditChangedCallbackC)++iMContextPreeditChangedClosure :: IMContextPreeditChangedCallback -> IO Closure+iMContextPreeditChangedClosure cb = newCClosure =<< mkIMContextPreeditChangedCallback wrapped+    where wrapped = iMContextPreeditChangedCallbackWrapper cb++iMContextPreeditChangedCallbackWrapper ::+    IMContextPreeditChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iMContextPreeditChangedCallbackWrapper _cb _ _ = do+    _cb ++onIMContextPreeditChanged :: (GObject a, MonadIO m) => a -> IMContextPreeditChangedCallback -> m SignalHandlerId+onIMContextPreeditChanged obj cb = liftIO $ connectIMContextPreeditChanged obj cb SignalConnectBefore+afterIMContextPreeditChanged :: (GObject a, MonadIO m) => a -> IMContextPreeditChangedCallback -> m SignalHandlerId+afterIMContextPreeditChanged obj cb = connectIMContextPreeditChanged obj cb SignalConnectAfter++connectIMContextPreeditChanged :: (GObject a, MonadIO m) =>+                                  a -> IMContextPreeditChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextPreeditChanged obj cb after = liftIO $ do+    cb' <- mkIMContextPreeditChangedCallback (iMContextPreeditChangedCallbackWrapper cb)+    connectSignalFunPtr obj "preedit-changed" cb' after++-- signal IMContext::preedit-end+type IMContextPreeditEndCallback =+    IO ()++noIMContextPreeditEndCallback :: Maybe IMContextPreeditEndCallback+noIMContextPreeditEndCallback = Nothing++type IMContextPreeditEndCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIMContextPreeditEndCallback :: IMContextPreeditEndCallbackC -> IO (FunPtr IMContextPreeditEndCallbackC)++iMContextPreeditEndClosure :: IMContextPreeditEndCallback -> IO Closure+iMContextPreeditEndClosure cb = newCClosure =<< mkIMContextPreeditEndCallback wrapped+    where wrapped = iMContextPreeditEndCallbackWrapper cb++iMContextPreeditEndCallbackWrapper ::+    IMContextPreeditEndCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iMContextPreeditEndCallbackWrapper _cb _ _ = do+    _cb ++onIMContextPreeditEnd :: (GObject a, MonadIO m) => a -> IMContextPreeditEndCallback -> m SignalHandlerId+onIMContextPreeditEnd obj cb = liftIO $ connectIMContextPreeditEnd obj cb SignalConnectBefore+afterIMContextPreeditEnd :: (GObject a, MonadIO m) => a -> IMContextPreeditEndCallback -> m SignalHandlerId+afterIMContextPreeditEnd obj cb = connectIMContextPreeditEnd obj cb SignalConnectAfter++connectIMContextPreeditEnd :: (GObject a, MonadIO m) =>+                              a -> IMContextPreeditEndCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextPreeditEnd obj cb after = liftIO $ do+    cb' <- mkIMContextPreeditEndCallback (iMContextPreeditEndCallbackWrapper cb)+    connectSignalFunPtr obj "preedit-end" cb' after++-- signal IMContext::preedit-start+type IMContextPreeditStartCallback =+    IO ()++noIMContextPreeditStartCallback :: Maybe IMContextPreeditStartCallback+noIMContextPreeditStartCallback = Nothing++type IMContextPreeditStartCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIMContextPreeditStartCallback :: IMContextPreeditStartCallbackC -> IO (FunPtr IMContextPreeditStartCallbackC)++iMContextPreeditStartClosure :: IMContextPreeditStartCallback -> IO Closure+iMContextPreeditStartClosure cb = newCClosure =<< mkIMContextPreeditStartCallback wrapped+    where wrapped = iMContextPreeditStartCallbackWrapper cb++iMContextPreeditStartCallbackWrapper ::+    IMContextPreeditStartCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iMContextPreeditStartCallbackWrapper _cb _ _ = do+    _cb ++onIMContextPreeditStart :: (GObject a, MonadIO m) => a -> IMContextPreeditStartCallback -> m SignalHandlerId+onIMContextPreeditStart obj cb = liftIO $ connectIMContextPreeditStart obj cb SignalConnectBefore+afterIMContextPreeditStart :: (GObject a, MonadIO m) => a -> IMContextPreeditStartCallback -> m SignalHandlerId+afterIMContextPreeditStart obj cb = connectIMContextPreeditStart obj cb SignalConnectAfter++connectIMContextPreeditStart :: (GObject a, MonadIO m) =>+                                a -> IMContextPreeditStartCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextPreeditStart obj cb after = liftIO $ do+    cb' <- mkIMContextPreeditStartCallback (iMContextPreeditStartCallbackWrapper cb)+    connectSignalFunPtr obj "preedit-start" cb' after++-- signal IMContext::retrieve-surrounding+type IMContextRetrieveSurroundingCallback =+    IO Bool++noIMContextRetrieveSurroundingCallback :: Maybe IMContextRetrieveSurroundingCallback+noIMContextRetrieveSurroundingCallback = Nothing++type IMContextRetrieveSurroundingCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkIMContextRetrieveSurroundingCallback :: IMContextRetrieveSurroundingCallbackC -> IO (FunPtr IMContextRetrieveSurroundingCallbackC)++iMContextRetrieveSurroundingClosure :: IMContextRetrieveSurroundingCallback -> IO Closure+iMContextRetrieveSurroundingClosure cb = newCClosure =<< mkIMContextRetrieveSurroundingCallback wrapped+    where wrapped = iMContextRetrieveSurroundingCallbackWrapper cb++iMContextRetrieveSurroundingCallbackWrapper ::+    IMContextRetrieveSurroundingCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+iMContextRetrieveSurroundingCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onIMContextRetrieveSurrounding :: (GObject a, MonadIO m) => a -> IMContextRetrieveSurroundingCallback -> m SignalHandlerId+onIMContextRetrieveSurrounding obj cb = liftIO $ connectIMContextRetrieveSurrounding obj cb SignalConnectBefore+afterIMContextRetrieveSurrounding :: (GObject a, MonadIO m) => a -> IMContextRetrieveSurroundingCallback -> m SignalHandlerId+afterIMContextRetrieveSurrounding obj cb = connectIMContextRetrieveSurrounding obj cb SignalConnectAfter++connectIMContextRetrieveSurrounding :: (GObject a, MonadIO m) =>+                                       a -> IMContextRetrieveSurroundingCallback -> SignalConnectMode -> m SignalHandlerId+connectIMContextRetrieveSurrounding obj cb after = liftIO $ do+    cb' <- mkIMContextRetrieveSurroundingCallback (iMContextRetrieveSurroundingCallbackWrapper cb)+    connectSignalFunPtr obj "retrieve-surrounding" cb' after++-- VVV Prop "input-hints"+   -- Type: TInterface "Gtk" "InputHints"+   -- Flags: [PropertyReadable,PropertyWritable]++getIMContextInputHints :: (MonadIO m, IMContextK o) => o -> m [InputHints]+getIMContextInputHints obj = liftIO $ getObjectPropertyFlags obj "input-hints"++setIMContextInputHints :: (MonadIO m, IMContextK o) => o -> [InputHints] -> m ()+setIMContextInputHints obj val = liftIO $ setObjectPropertyFlags obj "input-hints" val++constructIMContextInputHints :: [InputHints] -> IO ([Char], GValue)+constructIMContextInputHints val = constructObjectPropertyFlags "input-hints" val++data IMContextInputHintsPropertyInfo+instance AttrInfo IMContextInputHintsPropertyInfo where+    type AttrAllowedOps IMContextInputHintsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IMContextInputHintsPropertyInfo = (~) [InputHints]+    type AttrBaseTypeConstraint IMContextInputHintsPropertyInfo = IMContextK+    type AttrGetType IMContextInputHintsPropertyInfo = [InputHints]+    type AttrLabel IMContextInputHintsPropertyInfo = "IMContext::input-hints"+    attrGet _ = getIMContextInputHints+    attrSet _ = setIMContextInputHints+    attrConstruct _ = constructIMContextInputHints++-- VVV Prop "input-purpose"+   -- Type: TInterface "Gtk" "InputPurpose"+   -- Flags: [PropertyReadable,PropertyWritable]++getIMContextInputPurpose :: (MonadIO m, IMContextK o) => o -> m InputPurpose+getIMContextInputPurpose obj = liftIO $ getObjectPropertyEnum obj "input-purpose"++setIMContextInputPurpose :: (MonadIO m, IMContextK o) => o -> InputPurpose -> m ()+setIMContextInputPurpose obj val = liftIO $ setObjectPropertyEnum obj "input-purpose" val++constructIMContextInputPurpose :: InputPurpose -> IO ([Char], GValue)+constructIMContextInputPurpose val = constructObjectPropertyEnum "input-purpose" val++data IMContextInputPurposePropertyInfo+instance AttrInfo IMContextInputPurposePropertyInfo where+    type AttrAllowedOps IMContextInputPurposePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IMContextInputPurposePropertyInfo = (~) InputPurpose+    type AttrBaseTypeConstraint IMContextInputPurposePropertyInfo = IMContextK+    type AttrGetType IMContextInputPurposePropertyInfo = InputPurpose+    type AttrLabel IMContextInputPurposePropertyInfo = "IMContext::input-purpose"+    attrGet _ = getIMContextInputPurpose+    attrSet _ = setIMContextInputPurpose+    attrConstruct _ = constructIMContextInputPurpose++type instance AttributeList IMContext = IMContextAttributeList+type IMContextAttributeList = ('[ '("input-hints", IMContextInputHintsPropertyInfo), '("input-purpose", IMContextInputPurposePropertyInfo)] :: [(Symbol, *)])++data IMContextCommitSignalInfo+instance SignalInfo IMContextCommitSignalInfo where+    type HaskellCallbackType IMContextCommitSignalInfo = IMContextCommitCallback+    connectSignal _ = connectIMContextCommit++data IMContextDeleteSurroundingSignalInfo+instance SignalInfo IMContextDeleteSurroundingSignalInfo where+    type HaskellCallbackType IMContextDeleteSurroundingSignalInfo = IMContextDeleteSurroundingCallback+    connectSignal _ = connectIMContextDeleteSurrounding++data IMContextPreeditChangedSignalInfo+instance SignalInfo IMContextPreeditChangedSignalInfo where+    type HaskellCallbackType IMContextPreeditChangedSignalInfo = IMContextPreeditChangedCallback+    connectSignal _ = connectIMContextPreeditChanged++data IMContextPreeditEndSignalInfo+instance SignalInfo IMContextPreeditEndSignalInfo where+    type HaskellCallbackType IMContextPreeditEndSignalInfo = IMContextPreeditEndCallback+    connectSignal _ = connectIMContextPreeditEnd++data IMContextPreeditStartSignalInfo+instance SignalInfo IMContextPreeditStartSignalInfo where+    type HaskellCallbackType IMContextPreeditStartSignalInfo = IMContextPreeditStartCallback+    connectSignal _ = connectIMContextPreeditStart++data IMContextRetrieveSurroundingSignalInfo+instance SignalInfo IMContextRetrieveSurroundingSignalInfo where+    type HaskellCallbackType IMContextRetrieveSurroundingSignalInfo = IMContextRetrieveSurroundingCallback+    connectSignal _ = connectIMContextRetrieveSurrounding++type instance SignalList IMContext = IMContextSignalList+type IMContextSignalList = ('[ '("commit", IMContextCommitSignalInfo), '("delete-surrounding", IMContextDeleteSurroundingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("preedit-changed", IMContextPreeditChangedSignalInfo), '("preedit-end", IMContextPreeditEndSignalInfo), '("preedit-start", IMContextPreeditStartSignalInfo), '("retrieve-surrounding", IMContextRetrieveSurroundingSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IMContext::delete_surrounding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_im_context_delete_surrounding" gtk_im_context_delete_surrounding :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Int32 ->                                -- offset : TBasicType TInt32+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO CInt+++iMContextDeleteSurrounding ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- offset+    Int32 ->                                -- n_chars+    m Bool+iMContextDeleteSurrounding _obj offset n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_im_context_delete_surrounding _obj' offset n_chars+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IMContext::filter_keypress+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "event", argType = TInterface "Gdk" "EventKey", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_filter_keypress" gtk_im_context_filter_keypress :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Ptr Gdk.EventKey ->                     -- event : TInterface "Gdk" "EventKey"+    IO CInt+++iMContextFilterKeypress ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    Gdk.EventKey ->                         -- event+    m Bool+iMContextFilterKeypress _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    result <- gtk_im_context_filter_keypress _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++-- method IMContext::focus_in+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_focus_in" gtk_im_context_focus_in :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    IO ()+++iMContextFocusIn ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    m ()+iMContextFocusIn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_im_context_focus_in _obj'+    touchManagedPtr _obj+    return ()++-- method IMContext::focus_out+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_focus_out" gtk_im_context_focus_out :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    IO ()+++iMContextFocusOut ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    m ()+iMContextFocusOut _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_im_context_focus_out _obj'+    touchManagedPtr _obj+    return ()++-- method IMContext::get_preedit_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "attrs", argType = TInterface "Pango" "AttrList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cursor_pos", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_get_preedit_string" gtk_im_context_get_preedit_string :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Ptr CString ->                          -- str : TBasicType TUTF8+    Ptr (Ptr Pango.AttrList) ->             -- attrs : TInterface "Pango" "AttrList"+    Ptr Int32 ->                            -- cursor_pos : TBasicType TInt32+    IO ()+++iMContextGetPreeditString ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    m (T.Text,Pango.AttrList,Int32)+iMContextGetPreeditString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str <- allocMem :: IO (Ptr CString)+    attrs <- allocMem :: IO (Ptr (Ptr Pango.AttrList))+    cursor_pos <- allocMem :: IO (Ptr Int32)+    gtk_im_context_get_preedit_string _obj' str attrs cursor_pos+    str' <- peek str+    str'' <- cstringToText str'+    freeMem str'+    attrs' <- peek attrs+    attrs'' <- (wrapBoxed Pango.AttrList) attrs'+    cursor_pos' <- peek cursor_pos+    touchManagedPtr _obj+    freeMem str+    freeMem attrs+    freeMem cursor_pos+    return (str'', attrs'', cursor_pos')++-- method IMContext::get_surrounding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cursor_index", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_get_surrounding" gtk_im_context_get_surrounding :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Ptr CString ->                          -- text : TBasicType TUTF8+    Ptr Int32 ->                            -- cursor_index : TBasicType TInt32+    IO CInt+++iMContextGetSurrounding ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    m (Bool,T.Text,Int32)+iMContextGetSurrounding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text <- allocMem :: IO (Ptr CString)+    cursor_index <- allocMem :: IO (Ptr Int32)+    result <- gtk_im_context_get_surrounding _obj' text cursor_index+    let result' = (/= 0) result+    text' <- peek text+    text'' <- cstringToText text'+    freeMem text'+    cursor_index' <- peek cursor_index+    touchManagedPtr _obj+    freeMem text+    freeMem cursor_index+    return (result', text'', cursor_index')++-- method IMContext::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_reset" gtk_im_context_reset :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    IO ()+++iMContextReset ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    m ()+iMContextReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_im_context_reset _obj'+    touchManagedPtr _obj+    return ()++-- method IMContext::set_client_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_set_client_window" gtk_im_context_set_client_window :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Ptr Gdk.Window ->                       -- window : TInterface "Gdk" "Window"+    IO ()+++iMContextSetClientWindow ::+    (MonadIO m, IMContextK a, Gdk.WindowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- window+    m ()+iMContextSetClientWindow _obj window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWindow <- case window of+        Nothing -> return nullPtr+        Just jWindow -> do+            let jWindow' = unsafeManagedPtrCastPtr jWindow+            return jWindow'+    gtk_im_context_set_client_window _obj' maybeWindow+    touchManagedPtr _obj+    whenJust window touchManagedPtr+    return ()++-- method IMContext::set_cursor_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_set_cursor_location" gtk_im_context_set_cursor_location :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    Ptr Gdk.Rectangle ->                    -- area : TInterface "Gdk" "Rectangle"+    IO ()+++iMContextSetCursorLocation ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    Gdk.Rectangle ->                        -- area+    m ()+iMContextSetCursorLocation _obj area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let area' = unsafeManagedPtrGetPtr area+    gtk_im_context_set_cursor_location _obj' area'+    touchManagedPtr _obj+    touchManagedPtr area+    return ()++-- method IMContext::set_surrounding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = 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},Arg {argName = "cursor_index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = 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},Arg {argName = "cursor_index", 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 "gtk_im_context_set_surrounding" gtk_im_context_set_surrounding :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    CString ->                              -- text : TBasicType TUTF8+    Int32 ->                                -- len : TBasicType TInt32+    Int32 ->                                -- cursor_index : TBasicType TInt32+    IO ()+++iMContextSetSurrounding ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    Int32 ->                                -- len+    Int32 ->                                -- cursor_index+    m ()+iMContextSetSurrounding _obj text len cursor_index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_im_context_set_surrounding _obj' text' len cursor_index+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method IMContext::set_use_preedit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_preedit", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_preedit", 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 "gtk_im_context_set_use_preedit" gtk_im_context_set_use_preedit :: +    Ptr IMContext ->                        -- _obj : TInterface "Gtk" "IMContext"+    CInt ->                                 -- use_preedit : TBasicType TBoolean+    IO ()+++iMContextSetUsePreedit ::+    (MonadIO m, IMContextK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_preedit+    m ()+iMContextSetUsePreedit _obj use_preedit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_preedit' = (fromIntegral . fromEnum) use_preedit+    gtk_im_context_set_use_preedit _obj' use_preedit'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/IMContext.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.IMContext where++import Prelude ()+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 IMContext = IMContext (ForeignPtr IMContext)+instance GObject IMContext where+class GObject o => IMContextK o+instance (GObject o, IsDescendantOf IMContext o) => IMContextK o+data IMContextInputHintsPropertyInfo+data IMContextInputPurposePropertyInfo+data IMContextCommitSignalInfo+data IMContextDeleteSurroundingSignalInfo+data IMContextPreeditChangedSignalInfo+data IMContextPreeditEndSignalInfo+data IMContextPreeditStartSignalInfo+data IMContextRetrieveSurroundingSignalInfo
+ GI/Gtk/Objects/IMContextSimple.hs view
@@ -0,0 +1,87 @@++{- |+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.Gtk.Objects.IMContextSimple+    ( ++-- * Exported types+    IMContextSimple(..)                     ,+    IMContextSimpleK                        ,+    toIMContextSimple                       ,+    noIMContextSimple                       ,+++ -- * Methods+-- ** iMContextSimpleNew+    iMContextSimpleNew                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype IMContextSimple = IMContextSimple (ForeignPtr IMContextSimple)+foreign import ccall "gtk_im_context_simple_get_type"+    c_gtk_im_context_simple_get_type :: IO GType++type instance ParentTypes IMContextSimple = IMContextSimpleParentTypes+type IMContextSimpleParentTypes = '[IMContext, GObject.Object]++instance GObject IMContextSimple where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_im_context_simple_get_type+    ++class GObject o => IMContextSimpleK o+instance (GObject o, IsDescendantOf IMContextSimple o) => IMContextSimpleK o++toIMContextSimple :: IMContextSimpleK o => o -> IO IMContextSimple+toIMContextSimple = unsafeCastTo IMContextSimple++noIMContextSimple :: Maybe IMContextSimple+noIMContextSimple = Nothing++type instance AttributeList IMContextSimple = IMContextSimpleAttributeList+type IMContextSimpleAttributeList = ('[ '("input-hints", IMContextInputHintsPropertyInfo), '("input-purpose", IMContextInputPurposePropertyInfo)] :: [(Symbol, *)])++type instance SignalList IMContextSimple = IMContextSimpleSignalList+type IMContextSimpleSignalList = ('[ '("commit", IMContextCommitSignalInfo), '("delete-surrounding", IMContextDeleteSurroundingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("preedit-changed", IMContextPreeditChangedSignalInfo), '("preedit-end", IMContextPreeditEndSignalInfo), '("preedit-start", IMContextPreeditStartSignalInfo), '("retrieve-surrounding", IMContextRetrieveSurroundingSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IMContextSimple::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IMContextSimple"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_context_simple_new" gtk_im_context_simple_new :: +    IO (Ptr IMContextSimple)+++iMContextSimpleNew ::+    (MonadIO m) =>+    m IMContextSimple+iMContextSimpleNew  = liftIO $ do+    result <- gtk_im_context_simple_new+    checkUnexpectedReturnNULL "gtk_im_context_simple_new" result+    result' <- (wrapObject IMContextSimple) result+    return result'++
+ GI/Gtk/Objects/IMContextSimple.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.IMContextSimple where++import Prelude ()+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 IMContextSimple = IMContextSimple (ForeignPtr IMContextSimple)+instance GObject IMContextSimple where+class GObject o => IMContextSimpleK o+instance (GObject o, IsDescendantOf IMContextSimple o) => IMContextSimpleK o
+ GI/Gtk/Objects/IMMulticontext.hs view
@@ -0,0 +1,181 @@++{- |+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.Gtk.Objects.IMMulticontext+    ( ++-- * Exported types+    IMMulticontext(..)                      ,+    IMMulticontextK                         ,+    toIMMulticontext                        ,+    noIMMulticontext                        ,+++ -- * Methods+-- ** iMMulticontextAppendMenuitems+    iMMulticontextAppendMenuitems           ,+++-- ** iMMulticontextGetContextId+    iMMulticontextGetContextId              ,+++-- ** iMMulticontextNew+    iMMulticontextNew                       ,+++-- ** iMMulticontextSetContextId+    iMMulticontextSetContextId              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype IMMulticontext = IMMulticontext (ForeignPtr IMMulticontext)+foreign import ccall "gtk_im_multicontext_get_type"+    c_gtk_im_multicontext_get_type :: IO GType++type instance ParentTypes IMMulticontext = IMMulticontextParentTypes+type IMMulticontextParentTypes = '[IMContext, GObject.Object]++instance GObject IMMulticontext where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_im_multicontext_get_type+    ++class GObject o => IMMulticontextK o+instance (GObject o, IsDescendantOf IMMulticontext o) => IMMulticontextK o++toIMMulticontext :: IMMulticontextK o => o -> IO IMMulticontext+toIMMulticontext = unsafeCastTo IMMulticontext++noIMMulticontext :: Maybe IMMulticontext+noIMMulticontext = Nothing++type instance AttributeList IMMulticontext = IMMulticontextAttributeList+type IMMulticontextAttributeList = ('[ '("input-hints", IMContextInputHintsPropertyInfo), '("input-purpose", IMContextInputPurposePropertyInfo)] :: [(Symbol, *)])++type instance SignalList IMMulticontext = IMMulticontextSignalList+type IMMulticontextSignalList = ('[ '("commit", IMContextCommitSignalInfo), '("delete-surrounding", IMContextDeleteSurroundingSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("preedit-changed", IMContextPreeditChangedSignalInfo), '("preedit-end", IMContextPreeditEndSignalInfo), '("preedit-start", IMContextPreeditStartSignalInfo), '("retrieve-surrounding", IMContextRetrieveSurroundingSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IMMulticontext::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IMMulticontext"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_multicontext_new" gtk_im_multicontext_new :: +    IO (Ptr IMMulticontext)+++iMMulticontextNew ::+    (MonadIO m) =>+    m IMMulticontext+iMMulticontextNew  = liftIO $ do+    result <- gtk_im_multicontext_new+    checkUnexpectedReturnNULL "gtk_im_multicontext_new" result+    result' <- (wrapObject IMMulticontext) result+    return result'++-- method IMMulticontext::append_menuitems+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menushell", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menushell", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_multicontext_append_menuitems" gtk_im_multicontext_append_menuitems :: +    Ptr IMMulticontext ->                   -- _obj : TInterface "Gtk" "IMMulticontext"+    Ptr MenuShell ->                        -- menushell : TInterface "Gtk" "MenuShell"+    IO ()++{-# DEPRECATED iMMulticontextAppendMenuitems ["(Since version 3.10)","It is better to use the system-wide input","    method framework for changing input methods. Modern","    desktop shells offer on-screen displays for this that","    can triggered with a keyboard shortcut, e.g. Super-Space."]#-}+iMMulticontextAppendMenuitems ::+    (MonadIO m, IMMulticontextK a, MenuShellK b) =>+    a ->                                    -- _obj+    b ->                                    -- menushell+    m ()+iMMulticontextAppendMenuitems _obj menushell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let menushell' = unsafeManagedPtrCastPtr menushell+    gtk_im_multicontext_append_menuitems _obj' menushell'+    touchManagedPtr _obj+    touchManagedPtr menushell+    return ()++-- method IMMulticontext::get_context_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_im_multicontext_get_context_id" gtk_im_multicontext_get_context_id :: +    Ptr IMMulticontext ->                   -- _obj : TInterface "Gtk" "IMMulticontext"+    IO CString+++iMMulticontextGetContextId ::+    (MonadIO m, IMMulticontextK a) =>+    a ->                                    -- _obj+    m T.Text+iMMulticontextGetContextId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_im_multicontext_get_context_id _obj'+    checkUnexpectedReturnNULL "gtk_im_multicontext_get_context_id" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method IMMulticontext::set_context_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IMMulticontext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context_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 "gtk_im_multicontext_set_context_id" gtk_im_multicontext_set_context_id :: +    Ptr IMMulticontext ->                   -- _obj : TInterface "Gtk" "IMMulticontext"+    CString ->                              -- context_id : TBasicType TUTF8+    IO ()+++iMMulticontextSetContextId ::+    (MonadIO m, IMMulticontextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- context_id+    m ()+iMMulticontextSetContextId _obj context_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    context_id' <- textToCString context_id+    gtk_im_multicontext_set_context_id _obj' context_id'+    touchManagedPtr _obj+    freeMem context_id'+    return ()++
+ GI/Gtk/Objects/IMMulticontext.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.IMMulticontext where++import Prelude ()+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 IMMulticontext = IMMulticontext (ForeignPtr IMMulticontext)+instance GObject IMMulticontext where+class GObject o => IMMulticontextK o+instance (GObject o, IsDescendantOf IMMulticontext o) => IMMulticontextK o
+ GI/Gtk/Objects/IconFactory.hs view
@@ -0,0 +1,243 @@++{- |+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.Gtk.Objects.IconFactory+    ( ++-- * Exported types+    IconFactory(..)                         ,+    IconFactoryK                            ,+    toIconFactory                           ,+    noIconFactory                           ,+++ -- * Methods+-- ** iconFactoryAdd+    iconFactoryAdd                          ,+++-- ** iconFactoryAddDefault+    iconFactoryAddDefault                   ,+++-- ** iconFactoryLookup+    iconFactoryLookup                       ,+++-- ** iconFactoryLookupDefault+    iconFactoryLookupDefault                ,+++-- ** iconFactoryNew+    iconFactoryNew                          ,+++-- ** iconFactoryRemoveDefault+    iconFactoryRemoveDefault                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype IconFactory = IconFactory (ForeignPtr IconFactory)+foreign import ccall "gtk_icon_factory_get_type"+    c_gtk_icon_factory_get_type :: IO GType++type instance ParentTypes IconFactory = IconFactoryParentTypes+type IconFactoryParentTypes = '[GObject.Object, Buildable]++instance GObject IconFactory where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_icon_factory_get_type+    ++class GObject o => IconFactoryK o+instance (GObject o, IsDescendantOf IconFactory o) => IconFactoryK o++toIconFactory :: IconFactoryK o => o -> IO IconFactory+toIconFactory = unsafeCastTo IconFactory++noIconFactory :: Maybe IconFactory+noIconFactory = Nothing++type instance AttributeList IconFactory = IconFactoryAttributeList+type IconFactoryAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList IconFactory = IconFactorySignalList+type IconFactorySignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IconFactory::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IconFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_new" gtk_icon_factory_new :: +    IO (Ptr IconFactory)++{-# DEPRECATED iconFactoryNew ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryNew ::+    (MonadIO m) =>+    m IconFactory+iconFactoryNew  = liftIO $ do+    result <- gtk_icon_factory_new+    checkUnexpectedReturnNULL "gtk_icon_factory_new" result+    result' <- (wrapObject IconFactory) result+    return result'++-- method IconFactory::add+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_add" gtk_icon_factory_add :: +    Ptr IconFactory ->                      -- _obj : TInterface "Gtk" "IconFactory"+    CString ->                              -- stock_id : TBasicType TUTF8+    Ptr IconSet ->                          -- icon_set : TInterface "Gtk" "IconSet"+    IO ()++{-# DEPRECATED iconFactoryAdd ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryAdd ::+    (MonadIO m, IconFactoryK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- stock_id+    IconSet ->                              -- icon_set+    m ()+iconFactoryAdd _obj stock_id icon_set = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stock_id' <- textToCString stock_id+    let icon_set' = unsafeManagedPtrGetPtr icon_set+    gtk_icon_factory_add _obj' stock_id' icon_set'+    touchManagedPtr _obj+    touchManagedPtr icon_set+    freeMem stock_id'+    return ()++-- method IconFactory::add_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_add_default" gtk_icon_factory_add_default :: +    Ptr IconFactory ->                      -- _obj : TInterface "Gtk" "IconFactory"+    IO ()++{-# DEPRECATED iconFactoryAddDefault ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryAddDefault ::+    (MonadIO m, IconFactoryK a) =>+    a ->                                    -- _obj+    m ()+iconFactoryAddDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_factory_add_default _obj'+    touchManagedPtr _obj+    return ()++-- method IconFactory::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconSet"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_lookup" gtk_icon_factory_lookup :: +    Ptr IconFactory ->                      -- _obj : TInterface "Gtk" "IconFactory"+    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr IconSet)++{-# DEPRECATED iconFactoryLookup ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryLookup ::+    (MonadIO m, IconFactoryK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- stock_id+    m IconSet+iconFactoryLookup _obj stock_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stock_id' <- textToCString stock_id+    result <- gtk_icon_factory_lookup _obj' stock_id'+    checkUnexpectedReturnNULL "gtk_icon_factory_lookup" result+    result' <- (newBoxed IconSet) result+    touchManagedPtr _obj+    freeMem stock_id'+    return result'++-- method IconFactory::remove_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_remove_default" gtk_icon_factory_remove_default :: +    Ptr IconFactory ->                      -- _obj : TInterface "Gtk" "IconFactory"+    IO ()++{-# DEPRECATED iconFactoryRemoveDefault ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryRemoveDefault ::+    (MonadIO m, IconFactoryK a) =>+    a ->                                    -- _obj+    m ()+iconFactoryRemoveDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_factory_remove_default _obj'+    touchManagedPtr _obj+    return ()++-- method IconFactory::lookup_default+-- method type : MemberFunction+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconSet"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_factory_lookup_default" gtk_icon_factory_lookup_default :: +    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr IconSet)++{-# DEPRECATED iconFactoryLookupDefault ["(Since version 3.10)","Use #GtkIconTheme instead."]#-}+iconFactoryLookupDefault ::+    (MonadIO m) =>+    T.Text ->                               -- stock_id+    m IconSet+iconFactoryLookupDefault stock_id = liftIO $ do+    stock_id' <- textToCString stock_id+    result <- gtk_icon_factory_lookup_default stock_id'+    checkUnexpectedReturnNULL "gtk_icon_factory_lookup_default" result+    result' <- (newBoxed IconSet) result+    freeMem stock_id'+    return result'++
+ GI/Gtk/Objects/IconFactory.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.IconFactory where++import Prelude ()+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 IconFactory = IconFactory (ForeignPtr IconFactory)+instance GObject IconFactory where+class GObject o => IconFactoryK o+instance (GObject o, IsDescendantOf IconFactory o) => IconFactoryK o
+ GI/Gtk/Objects/IconInfo.hs view
@@ -0,0 +1,914 @@++{- |+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.Gtk.Objects.IconInfo+    ( ++-- * Exported types+    IconInfo(..)                            ,+    IconInfoK                               ,+    toIconInfo                              ,+    noIconInfo                              ,+++ -- * Methods+-- ** iconInfoGetAttachPoints+    iconInfoGetAttachPoints                 ,+++-- ** iconInfoGetBaseScale+    iconInfoGetBaseScale                    ,+++-- ** iconInfoGetBaseSize+    iconInfoGetBaseSize                     ,+++-- ** iconInfoGetBuiltinPixbuf+    iconInfoGetBuiltinPixbuf                ,+++-- ** iconInfoGetDisplayName+    iconInfoGetDisplayName                  ,+++-- ** iconInfoGetEmbeddedRect+    iconInfoGetEmbeddedRect                 ,+++-- ** iconInfoGetFilename+    iconInfoGetFilename                     ,+++-- ** iconInfoIsSymbolic+    iconInfoIsSymbolic                      ,+++-- ** iconInfoLoadIcon+    iconInfoLoadIcon                        ,+++-- ** iconInfoLoadIconAsync+    iconInfoLoadIconAsync                   ,+++-- ** iconInfoLoadIconFinish+    iconInfoLoadIconFinish                  ,+++-- ** iconInfoLoadSurface+    iconInfoLoadSurface                     ,+++-- ** iconInfoLoadSymbolic+    iconInfoLoadSymbolic                    ,+++-- ** iconInfoLoadSymbolicAsync+    iconInfoLoadSymbolicAsync               ,+++-- ** iconInfoLoadSymbolicFinish+    iconInfoLoadSymbolicFinish              ,+++-- ** iconInfoLoadSymbolicForContext+    iconInfoLoadSymbolicForContext          ,+++-- ** iconInfoLoadSymbolicForContextAsync+    iconInfoLoadSymbolicForContextAsync     ,+++-- ** iconInfoLoadSymbolicForContextFinish+    iconInfoLoadSymbolicForContextFinish    ,+++-- ** iconInfoLoadSymbolicForStyle+    iconInfoLoadSymbolicForStyle            ,+++-- ** iconInfoNewForPixbuf+    iconInfoNewForPixbuf                    ,+++-- ** iconInfoSetRawCoordinates+    iconInfoSetRawCoordinates               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Cairo as Cairo++newtype IconInfo = IconInfo (ForeignPtr IconInfo)+foreign import ccall "gtk_icon_info_get_type"+    c_gtk_icon_info_get_type :: IO GType++type instance ParentTypes IconInfo = IconInfoParentTypes+type IconInfoParentTypes = '[GObject.Object]++instance GObject IconInfo where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_icon_info_get_type+    ++class GObject o => IconInfoK o+instance (GObject o, IsDescendantOf IconInfo o) => IconInfoK o++toIconInfo :: IconInfoK o => o -> IO IconInfo+toIconInfo = unsafeCastTo IconInfo++noIconInfo :: Maybe IconInfo+noIconInfo = Nothing++type instance AttributeList IconInfo = IconInfoAttributeList+type IconInfoAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList IconInfo = IconInfoSignalList+type IconInfoSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IconInfo::new_for_pixbuf+-- method type : Constructor+-- Args : [Arg {argName = "icon_theme", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon_theme", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_new_for_pixbuf" gtk_icon_info_new_for_pixbuf :: +    Ptr IconTheme ->                        -- icon_theme : TInterface "Gtk" "IconTheme"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO (Ptr IconInfo)+++iconInfoNewForPixbuf ::+    (MonadIO m, IconThemeK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- icon_theme+    b ->                                    -- pixbuf+    m IconInfo+iconInfoNewForPixbuf icon_theme pixbuf = liftIO $ do+    let icon_theme' = unsafeManagedPtrCastPtr icon_theme+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    result <- gtk_icon_info_new_for_pixbuf icon_theme' pixbuf'+    checkUnexpectedReturnNULL "gtk_icon_info_new_for_pixbuf" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr icon_theme+    touchManagedPtr pixbuf+    return result'++-- method IconInfo::get_attach_points+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "points", argType = TCArray False (-1) 2 (TInterface "Gdk" "Point"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "n_points", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_points", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_attach_points" gtk_icon_info_get_attach_points :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr (Ptr Gdk.Point) ->                  -- points : TCArray False (-1) 2 (TInterface "Gdk" "Point")+    Ptr Int32 ->                            -- n_points : TBasicType TInt32+    IO CInt++{-# DEPRECATED iconInfoGetAttachPoints ["(Since version 3.14)","Attachment points are deprecated"]#-}+iconInfoGetAttachPoints ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m (Bool,[Gdk.Point])+iconInfoGetAttachPoints _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    points <- allocMem :: IO (Ptr (Ptr Gdk.Point))+    n_points <- allocMem :: IO (Ptr Int32)+    result <- gtk_icon_info_get_attach_points _obj' points n_points+    n_points' <- peek n_points+    let result' = (/= 0) result+    points' <- peek points+    points'' <- (unpackBlockArrayWithLength 8 n_points') points'+    points''' <- mapM (wrapPtr Gdk.Point) points''+    freeMem points'+    touchManagedPtr _obj+    freeMem points+    freeMem n_points+    return (result', points''')++-- method IconInfo::get_base_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_base_scale" gtk_icon_info_get_base_scale :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO Int32+++iconInfoGetBaseScale ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m Int32+iconInfoGetBaseScale _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_get_base_scale _obj'+    touchManagedPtr _obj+    return result++-- method IconInfo::get_base_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_base_size" gtk_icon_info_get_base_size :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO Int32+++iconInfoGetBaseSize ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m Int32+iconInfoGetBaseSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_get_base_size _obj'+    touchManagedPtr _obj+    return result++-- method IconInfo::get_builtin_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_builtin_pixbuf" gtk_icon_info_get_builtin_pixbuf :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO (Ptr GdkPixbuf.Pixbuf)++{-# DEPRECATED iconInfoGetBuiltinPixbuf ["(Since version 3.14)","This function is deprecated, use","    gtk_icon_theme_add_resource_path() instead of builtin icons."]#-}+iconInfoGetBuiltinPixbuf ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+iconInfoGetBuiltinPixbuf _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_get_builtin_pixbuf _obj'+    checkUnexpectedReturnNULL "gtk_icon_info_get_builtin_pixbuf" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method IconInfo::get_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_display_name" gtk_icon_info_get_display_name :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO CString++{-# DEPRECATED iconInfoGetDisplayName ["(Since version 3.14)","Display names are deprecated"]#-}+iconInfoGetDisplayName ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m T.Text+iconInfoGetDisplayName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_get_display_name _obj'+    checkUnexpectedReturnNULL "gtk_icon_info_get_display_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method IconInfo::get_embedded_rect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rectangle", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_embedded_rect" gtk_icon_info_get_embedded_rect :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gdk.Rectangle ->                    -- rectangle : TInterface "Gdk" "Rectangle"+    IO CInt++{-# DEPRECATED iconInfoGetEmbeddedRect ["(Since version 3.14)","Embedded rectangles are deprecated"]#-}+iconInfoGetEmbeddedRect ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m (Bool,Gdk.Rectangle)+iconInfoGetEmbeddedRect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rectangle <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_icon_info_get_embedded_rect _obj' rectangle+    let result' = (/= 0) result+    rectangle' <- (wrapBoxed Gdk.Rectangle) rectangle+    touchManagedPtr _obj+    return (result', rectangle')++-- method IconInfo::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFileName+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_get_filename" gtk_icon_info_get_filename :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO CString+++iconInfoGetFilename ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m [Char]+iconInfoGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_get_filename _obj'+    checkUnexpectedReturnNULL "gtk_icon_info_get_filename" result+    result' <- cstringToString result+    touchManagedPtr _obj+    return result'++-- method IconInfo::is_symbolic+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_is_symbolic" gtk_icon_info_is_symbolic :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    IO CInt+++iconInfoIsSymbolic ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m Bool+iconInfoIsSymbolic _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_info_is_symbolic _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IconInfo::load_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_icon" gtk_icon_info_load_icon :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadIcon ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+iconInfoLoadIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        result <- propagateGError $ gtk_icon_info_load_icon _obj'+        checkUnexpectedReturnNULL "gtk_icon_info_load_icon" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        touchManagedPtr _obj+        return result'+     ) (do+        return ()+     )++-- method IconInfo::load_icon_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -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 "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -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 "gtk_icon_info_load_icon_async" gtk_icon_info_load_icon_async :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr Gio.AsyncReadyCallbackC ->       -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++iconInfoLoadIconAsync ::+    (MonadIO m, IconInfoK a, Gio.CancellableK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- cancellable+    Maybe (Gio.AsyncReadyCallback) ->       -- callback+    m ()+iconInfoLoadIconAsync _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 Gio.AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- Gio.mkAsyncReadyCallback (Gio.asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    gtk_icon_info_load_icon_async _obj' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    whenJust cancellable touchManagedPtr+    return ()++-- method IconInfo::load_icon_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", 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 "Gtk" "IconInfo", 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 "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_icon_finish" gtk_icon_info_load_icon_finish :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gio.AsyncResult ->                  -- res : TInterface "Gio" "AsyncResult"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadIconFinish ::+    (MonadIO m, IconInfoK a, Gio.AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m GdkPixbuf.Pixbuf+iconInfoLoadIconFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    onException (do+        result <- propagateGError $ gtk_icon_info_load_icon_finish _obj' res'+        checkUnexpectedReturnNULL "gtk_icon_info_load_icon_finish" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        touchManagedPtr _obj+        touchManagedPtr res+        return result'+     ) (do+        return ()+     )++-- method IconInfo::load_surface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_surface" gtk_icon_info_load_surface :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gdk.Window ->                       -- for_window : TInterface "Gdk" "Window"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Cairo.Surface)+++iconInfoLoadSurface ::+    (MonadIO m, IconInfoK a, Gdk.WindowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- for_window+    m Cairo.Surface+iconInfoLoadSurface _obj for_window = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFor_window <- case for_window of+        Nothing -> return nullPtr+        Just jFor_window -> do+            let jFor_window' = unsafeManagedPtrCastPtr jFor_window+            return jFor_window'+    onException (do+        result <- propagateGError $ gtk_icon_info_load_surface _obj' maybeFor_window+        checkUnexpectedReturnNULL "gtk_icon_info_load_surface" result+        result' <- (wrapBoxed Cairo.Surface) result+        touchManagedPtr _obj+        whenJust for_window touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method IconInfo::load_symbolic+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fg", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "was_symbolic", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fg", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic" gtk_icon_info_load_symbolic :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gdk.RGBA ->                         -- fg : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- success_color : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- warning_color : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- error_color : TInterface "Gdk" "RGBA"+    Ptr CInt ->                             -- was_symbolic : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadSymbolic ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- fg+    Maybe (Gdk.RGBA) ->                     -- success_color+    Maybe (Gdk.RGBA) ->                     -- warning_color+    Maybe (Gdk.RGBA) ->                     -- error_color+    m (GdkPixbuf.Pixbuf,Bool)+iconInfoLoadSymbolic _obj fg success_color warning_color error_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fg' = unsafeManagedPtrGetPtr fg+    maybeSuccess_color <- case success_color of+        Nothing -> return nullPtr+        Just jSuccess_color -> do+            let jSuccess_color' = unsafeManagedPtrGetPtr jSuccess_color+            return jSuccess_color'+    maybeWarning_color <- case warning_color of+        Nothing -> return nullPtr+        Just jWarning_color -> do+            let jWarning_color' = unsafeManagedPtrGetPtr jWarning_color+            return jWarning_color'+    maybeError_color <- case error_color of+        Nothing -> return nullPtr+        Just jError_color -> do+            let jError_color' = unsafeManagedPtrGetPtr jError_color+            return jError_color'+    was_symbolic <- allocMem :: IO (Ptr CInt)+    onException (do+        result <- propagateGError $ gtk_icon_info_load_symbolic _obj' fg' maybeSuccess_color maybeWarning_color maybeError_color was_symbolic+        checkUnexpectedReturnNULL "gtk_icon_info_load_symbolic" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        was_symbolic' <- peek was_symbolic+        let was_symbolic'' = (/= 0) was_symbolic'+        touchManagedPtr _obj+        touchManagedPtr fg+        whenJust success_color touchManagedPtr+        whenJust warning_color touchManagedPtr+        whenJust error_color touchManagedPtr+        freeMem was_symbolic+        return (result', was_symbolic'')+     ) (do+        freeMem was_symbolic+     )++-- method IconInfo::load_symbolic_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fg", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_color", argType = TInterface "Gdk" "RGBA", 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 = 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 "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fg", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "success_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "warning_color", argType = TInterface "Gdk" "RGBA", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "error_color", argType = TInterface "Gdk" "RGBA", 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 = 7, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic_async" gtk_icon_info_load_symbolic_async :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gdk.RGBA ->                         -- fg : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- success_color : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- warning_color : TInterface "Gdk" "RGBA"+    Ptr Gdk.RGBA ->                         -- error_color : TInterface "Gdk" "RGBA"+    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr Gio.AsyncReadyCallbackC ->       -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++iconInfoLoadSymbolicAsync ::+    (MonadIO m, IconInfoK a, Gio.CancellableK b) =>+    a ->                                    -- _obj+    Gdk.RGBA ->                             -- fg+    Maybe (Gdk.RGBA) ->                     -- success_color+    Maybe (Gdk.RGBA) ->                     -- warning_color+    Maybe (Gdk.RGBA) ->                     -- error_color+    Maybe (b) ->                            -- cancellable+    Maybe (Gio.AsyncReadyCallback) ->       -- callback+    m ()+iconInfoLoadSymbolicAsync _obj fg success_color warning_color error_color cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fg' = unsafeManagedPtrGetPtr fg+    maybeSuccess_color <- case success_color of+        Nothing -> return nullPtr+        Just jSuccess_color -> do+            let jSuccess_color' = unsafeManagedPtrGetPtr jSuccess_color+            return jSuccess_color'+    maybeWarning_color <- case warning_color of+        Nothing -> return nullPtr+        Just jWarning_color -> do+            let jWarning_color' = unsafeManagedPtrGetPtr jWarning_color+            return jWarning_color'+    maybeError_color <- case error_color of+        Nothing -> return nullPtr+        Just jError_color -> do+            let jError_color' = unsafeManagedPtrGetPtr jError_color+            return jError_color'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- Gio.mkAsyncReadyCallback (Gio.asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    gtk_icon_info_load_symbolic_async _obj' fg' maybeSuccess_color maybeWarning_color maybeError_color maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr fg+    whenJust success_color touchManagedPtr+    whenJust warning_color touchManagedPtr+    whenJust error_color touchManagedPtr+    whenJust cancellable touchManagedPtr+    return ()++-- method IconInfo::load_symbolic_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", 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 = "was_symbolic", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", 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 "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic_finish" gtk_icon_info_load_symbolic_finish :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gio.AsyncResult ->                  -- res : TInterface "Gio" "AsyncResult"+    Ptr CInt ->                             -- was_symbolic : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadSymbolicFinish ::+    (MonadIO m, IconInfoK a, Gio.AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (GdkPixbuf.Pixbuf,Bool)+iconInfoLoadSymbolicFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    was_symbolic <- allocMem :: IO (Ptr CInt)+    onException (do+        result <- propagateGError $ gtk_icon_info_load_symbolic_finish _obj' res' was_symbolic+        checkUnexpectedReturnNULL "gtk_icon_info_load_symbolic_finish" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        was_symbolic' <- peek was_symbolic+        let was_symbolic'' = (/= 0) was_symbolic'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem was_symbolic+        return (result', was_symbolic'')+     ) (do+        freeMem was_symbolic+     )++-- method IconInfo::load_symbolic_for_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "was_symbolic", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic_for_context" gtk_icon_info_load_symbolic_for_context :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr CInt ->                             -- was_symbolic : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadSymbolicForContext ::+    (MonadIO m, IconInfoK a, StyleContextK b) =>+    a ->                                    -- _obj+    b ->                                    -- context+    m (GdkPixbuf.Pixbuf,Bool)+iconInfoLoadSymbolicForContext _obj context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    was_symbolic <- allocMem :: IO (Ptr CInt)+    onException (do+        result <- propagateGError $ gtk_icon_info_load_symbolic_for_context _obj' context' was_symbolic+        checkUnexpectedReturnNULL "gtk_icon_info_load_symbolic_for_context" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        was_symbolic' <- peek was_symbolic+        let was_symbolic'' = (/= 0) was_symbolic'+        touchManagedPtr _obj+        touchManagedPtr context+        freeMem was_symbolic+        return (result', was_symbolic'')+     ) (do+        freeMem was_symbolic+     )++-- method IconInfo::load_symbolic_for_context_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -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 "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -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 "gtk_icon_info_load_symbolic_for_context_async" gtk_icon_info_load_symbolic_for_context_async :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"+    FunPtr Gio.AsyncReadyCallbackC ->       -- callback : TInterface "Gio" "AsyncReadyCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++iconInfoLoadSymbolicForContextAsync ::+    (MonadIO m, IconInfoK a, StyleContextK b, Gio.CancellableK c) =>+    a ->                                    -- _obj+    b ->                                    -- context+    Maybe (c) ->                            -- cancellable+    Maybe (Gio.AsyncReadyCallback) ->       -- callback+    m ()+iconInfoLoadSymbolicForContextAsync _obj context cancellable callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrCastPtr context+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.AsyncReadyCallbackC))+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            jCallback' <- Gio.mkAsyncReadyCallback (Gio.asyncReadyCallbackWrapper (Just ptrcallback) jCallback)+            poke ptrcallback jCallback'+            return jCallback'+    let user_data = nullPtr+    gtk_icon_info_load_symbolic_for_context_async _obj' context' maybeCancellable maybeCallback user_data+    touchManagedPtr _obj+    touchManagedPtr context+    whenJust cancellable touchManagedPtr+    return ()++-- method IconInfo::load_symbolic_for_context_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", 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 = "was_symbolic", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", 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 "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic_for_context_finish" gtk_icon_info_load_symbolic_for_context_finish :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Gio.AsyncResult ->                  -- res : TInterface "Gio" "AsyncResult"+    Ptr CInt ->                             -- was_symbolic : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconInfoLoadSymbolicForContextFinish ::+    (MonadIO m, IconInfoK a, Gio.AsyncResultK b) =>+    a ->                                    -- _obj+    b ->                                    -- res+    m (GdkPixbuf.Pixbuf,Bool)+iconInfoLoadSymbolicForContextFinish _obj res = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let res' = unsafeManagedPtrCastPtr res+    was_symbolic <- allocMem :: IO (Ptr CInt)+    onException (do+        result <- propagateGError $ gtk_icon_info_load_symbolic_for_context_finish _obj' res' was_symbolic+        checkUnexpectedReturnNULL "gtk_icon_info_load_symbolic_for_context_finish" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        was_symbolic' <- peek was_symbolic+        let was_symbolic'' = (/= 0) was_symbolic'+        touchManagedPtr _obj+        touchManagedPtr res+        freeMem was_symbolic+        return (result', was_symbolic'')+     ) (do+        freeMem was_symbolic+     )++-- method IconInfo::load_symbolic_for_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "was_symbolic", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "Style", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TInterface "Gtk" "StateType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_info_load_symbolic_for_style" gtk_icon_info_load_symbolic_for_style :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    Ptr Style ->                            -- style : TInterface "Gtk" "Style"+    CUInt ->                                -- state : TInterface "Gtk" "StateType"+    Ptr CInt ->                             -- was_symbolic : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)++{-# DEPRECATED iconInfoLoadSymbolicForStyle ["(Since version 3.0)","Use gtk_icon_info_load_symbolic_for_context() instead"]#-}+iconInfoLoadSymbolicForStyle ::+    (MonadIO m, IconInfoK a, StyleK b) =>+    a ->                                    -- _obj+    b ->                                    -- style+    StateType ->                            -- state+    m (GdkPixbuf.Pixbuf,Bool)+iconInfoLoadSymbolicForStyle _obj style state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let style' = unsafeManagedPtrCastPtr style+    let state' = (fromIntegral . fromEnum) state+    was_symbolic <- allocMem :: IO (Ptr CInt)+    onException (do+        result <- propagateGError $ gtk_icon_info_load_symbolic_for_style _obj' style' state' was_symbolic+        checkUnexpectedReturnNULL "gtk_icon_info_load_symbolic_for_style" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        was_symbolic' <- peek was_symbolic+        let was_symbolic'' = (/= 0) was_symbolic'+        touchManagedPtr _obj+        touchManagedPtr style+        freeMem was_symbolic+        return (result', was_symbolic'')+     ) (do+        freeMem was_symbolic+     )++-- method IconInfo::set_raw_coordinates+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "raw_coordinates", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "raw_coordinates", 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 "gtk_icon_info_set_raw_coordinates" gtk_icon_info_set_raw_coordinates :: +    Ptr IconInfo ->                         -- _obj : TInterface "Gtk" "IconInfo"+    CInt ->                                 -- raw_coordinates : TBasicType TBoolean+    IO ()++{-# DEPRECATED iconInfoSetRawCoordinates ["(Since version 3.14)","Embedded rectangles and attachment points are deprecated"]#-}+iconInfoSetRawCoordinates ::+    (MonadIO m, IconInfoK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- raw_coordinates+    m ()+iconInfoSetRawCoordinates _obj raw_coordinates = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let raw_coordinates' = (fromIntegral . fromEnum) raw_coordinates+    gtk_icon_info_set_raw_coordinates _obj' raw_coordinates'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/IconInfo.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.IconInfo where++import Prelude ()+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 IconInfo = IconInfo (ForeignPtr IconInfo)+instance GObject IconInfo where+class GObject o => IconInfoK o+instance (GObject o, IsDescendantOf IconInfo o) => IconInfoK o
+ GI/Gtk/Objects/IconTheme.hs view
@@ -0,0 +1,1065 @@++{- |+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.Gtk.Objects.IconTheme+    ( ++-- * Exported types+    IconTheme(..)                           ,+    IconThemeK                              ,+    toIconTheme                             ,+    noIconTheme                             ,+++ -- * Methods+-- ** iconThemeAddBuiltinIcon+    iconThemeAddBuiltinIcon                 ,+++-- ** iconThemeAddResourcePath+    iconThemeAddResourcePath                ,+++-- ** iconThemeAppendSearchPath+    iconThemeAppendSearchPath               ,+++-- ** iconThemeChooseIcon+    iconThemeChooseIcon                     ,+++-- ** iconThemeChooseIconForScale+    iconThemeChooseIconForScale             ,+++-- ** iconThemeGetDefault+    iconThemeGetDefault                     ,+++-- ** iconThemeGetExampleIconName+    iconThemeGetExampleIconName             ,+++-- ** iconThemeGetForScreen+    iconThemeGetForScreen                   ,+++-- ** iconThemeGetIconSizes+    iconThemeGetIconSizes                   ,+++-- ** iconThemeGetSearchPath+    iconThemeGetSearchPath                  ,+++-- ** iconThemeHasIcon+    iconThemeHasIcon                        ,+++-- ** iconThemeListContexts+    iconThemeListContexts                   ,+++-- ** iconThemeListIcons+    iconThemeListIcons                      ,+++-- ** iconThemeLoadIcon+    iconThemeLoadIcon                       ,+++-- ** iconThemeLoadIconForScale+    iconThemeLoadIconForScale               ,+++-- ** iconThemeLoadSurface+    iconThemeLoadSurface                    ,+++-- ** iconThemeLookupByGicon+    iconThemeLookupByGicon                  ,+++-- ** iconThemeLookupByGiconForScale+    iconThemeLookupByGiconForScale          ,+++-- ** iconThemeLookupIcon+    iconThemeLookupIcon                     ,+++-- ** iconThemeLookupIconForScale+    iconThemeLookupIconForScale             ,+++-- ** iconThemeNew+    iconThemeNew                            ,+++-- ** iconThemePrependSearchPath+    iconThemePrependSearchPath              ,+++-- ** iconThemeRescanIfNeeded+    iconThemeRescanIfNeeded                 ,+++-- ** iconThemeSetCustomTheme+    iconThemeSetCustomTheme                 ,+++-- ** iconThemeSetScreen+    iconThemeSetScreen                      ,+++-- ** iconThemeSetSearchPath+    iconThemeSetSearchPath                  ,+++++ -- * Signals+-- ** Changed+    IconThemeChangedCallback                ,+    IconThemeChangedCallbackC               ,+    IconThemeChangedSignalInfo              ,+    afterIconThemeChanged                   ,+    iconThemeChangedCallbackWrapper         ,+    iconThemeChangedClosure                 ,+    mkIconThemeChangedCallback              ,+    noIconThemeChangedCallback              ,+    onIconThemeChanged                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Cairo as Cairo++newtype IconTheme = IconTheme (ForeignPtr IconTheme)+foreign import ccall "gtk_icon_theme_get_type"+    c_gtk_icon_theme_get_type :: IO GType++type instance ParentTypes IconTheme = IconThemeParentTypes+type IconThemeParentTypes = '[GObject.Object]++instance GObject IconTheme where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_icon_theme_get_type+    ++class GObject o => IconThemeK o+instance (GObject o, IsDescendantOf IconTheme o) => IconThemeK o++toIconTheme :: IconThemeK o => o -> IO IconTheme+toIconTheme = unsafeCastTo IconTheme++noIconTheme :: Maybe IconTheme+noIconTheme = Nothing++-- signal IconTheme::changed+type IconThemeChangedCallback =+    IO ()++noIconThemeChangedCallback :: Maybe IconThemeChangedCallback+noIconThemeChangedCallback = Nothing++type IconThemeChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconThemeChangedCallback :: IconThemeChangedCallbackC -> IO (FunPtr IconThemeChangedCallbackC)++iconThemeChangedClosure :: IconThemeChangedCallback -> IO Closure+iconThemeChangedClosure cb = newCClosure =<< mkIconThemeChangedCallback wrapped+    where wrapped = iconThemeChangedCallbackWrapper cb++iconThemeChangedCallbackWrapper ::+    IconThemeChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconThemeChangedCallbackWrapper _cb _ _ = do+    _cb ++onIconThemeChanged :: (GObject a, MonadIO m) => a -> IconThemeChangedCallback -> m SignalHandlerId+onIconThemeChanged obj cb = liftIO $ connectIconThemeChanged obj cb SignalConnectBefore+afterIconThemeChanged :: (GObject a, MonadIO m) => a -> IconThemeChangedCallback -> m SignalHandlerId+afterIconThemeChanged obj cb = connectIconThemeChanged obj cb SignalConnectAfter++connectIconThemeChanged :: (GObject a, MonadIO m) =>+                           a -> IconThemeChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectIconThemeChanged obj cb after = liftIO $ do+    cb' <- mkIconThemeChangedCallback (iconThemeChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++type instance AttributeList IconTheme = IconThemeAttributeList+type IconThemeAttributeList = ('[ ] :: [(Symbol, *)])++data IconThemeChangedSignalInfo+instance SignalInfo IconThemeChangedSignalInfo where+    type HaskellCallbackType IconThemeChangedSignalInfo = IconThemeChangedCallback+    connectSignal _ = connectIconThemeChanged++type instance SignalList IconTheme = IconThemeSignalList+type IconThemeSignalList = ('[ '("changed", IconThemeChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IconTheme::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IconTheme"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_new" gtk_icon_theme_new :: +    IO (Ptr IconTheme)+++iconThemeNew ::+    (MonadIO m) =>+    m IconTheme+iconThemeNew  = liftIO $ do+    result <- gtk_icon_theme_new+    checkUnexpectedReturnNULL "gtk_icon_theme_new" result+    result' <- (wrapObject IconTheme) result+    return result'++-- method IconTheme::add_resource_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", 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 "Gtk" "IconTheme", 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 "gtk_icon_theme_add_resource_path" gtk_icon_theme_add_resource_path :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- path : TBasicType TUTF8+    IO ()+++iconThemeAddResourcePath ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- path+    m ()+iconThemeAddResourcePath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    gtk_icon_theme_add_resource_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method IconTheme::append_search_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_append_search_path" gtk_icon_theme_append_search_path :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- path : TBasicType TFileName+    IO ()+++iconThemeAppendSearchPath ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- path+    m ()+iconThemeAppendSearchPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- stringToCString path+    gtk_icon_theme_append_search_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method IconTheme::choose_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_names", argType = TCArray True (-1) (-1) (TBasicType TUTF8), 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_names", argType = TCArray True (-1) (-1) (TBasicType TUTF8), 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_choose_icon" gtk_icon_theme_choose_icon :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr CString ->                          -- icon_names : TCArray True (-1) (-1) (TBasicType TUTF8)+    Int32 ->                                -- size : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeChooseIcon ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- icon_names+    Int32 ->                                -- size+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeChooseIcon _obj icon_names size flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_names' <- packZeroTerminatedUTF8CArray icon_names+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_choose_icon _obj' icon_names' size flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_choose_icon" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem icon_names'+    freeMem icon_names'+    return result'++-- method IconTheme::choose_icon_for_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_names", argType = TCArray True (-1) (-1) (TBasicType TUTF8), 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_names", argType = TCArray True (-1) (-1) (TBasicType TUTF8), 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_choose_icon_for_scale" gtk_icon_theme_choose_icon_for_scale :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr CString ->                          -- icon_names : TCArray True (-1) (-1) (TBasicType TUTF8)+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- scale : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeChooseIconForScale ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    [T.Text] ->                             -- icon_names+    Int32 ->                                -- size+    Int32 ->                                -- scale+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeChooseIconForScale _obj icon_names size scale flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_names' <- packZeroTerminatedUTF8CArray icon_names+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_choose_icon_for_scale _obj' icon_names' size scale flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_choose_icon_for_scale" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem icon_names'+    freeMem icon_names'+    return result'++-- method IconTheme::get_example_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_get_example_icon_name" gtk_icon_theme_get_example_icon_name :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    IO CString+++iconThemeGetExampleIconName ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    m T.Text+iconThemeGetExampleIconName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_theme_get_example_icon_name _obj'+    checkUnexpectedReturnNULL "gtk_icon_theme_get_example_icon_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method IconTheme::get_icon_sizes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TInt32)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_get_icon_sizes" gtk_icon_theme_get_icon_sizes :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO (Ptr Int32)+++iconThemeGetIconSizes ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    m [Int32]+iconThemeGetIconSizes _obj icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    result <- gtk_icon_theme_get_icon_sizes _obj' icon_name'+    checkUnexpectedReturnNULL "gtk_icon_theme_get_icon_sizes" result+    result' <- unpackZeroTerminatedStorableArray result+    freeMem result+    touchManagedPtr _obj+    freeMem icon_name'+    return result'++-- method IconTheme::get_search_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TCArray False (-1) 2 (TBasicType TFileName), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "n_elements", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_elements", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_get_search_path" gtk_icon_theme_get_search_path :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr (Ptr CString) ->                    -- path : TCArray False (-1) 2 (TBasicType TFileName)+    Ptr Int32 ->                            -- n_elements : TBasicType TInt32+    IO ()+++iconThemeGetSearchPath ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    m ([[Char]])+iconThemeGetSearchPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path <- allocMem :: IO (Ptr (Ptr CString))+    n_elements <- allocMem :: IO (Ptr Int32)+    gtk_icon_theme_get_search_path _obj' path n_elements+    n_elements' <- peek n_elements+    path' <- peek path+    path'' <- (unpackFileNameArrayWithLength n_elements') path'+    (mapCArrayWithLength n_elements') freeMem path'+    freeMem path'+    touchManagedPtr _obj+    freeMem path+    freeMem n_elements+    return path''++-- method IconTheme::has_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_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 "gtk_icon_theme_has_icon" gtk_icon_theme_has_icon :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO CInt+++iconThemeHasIcon ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    m Bool+iconThemeHasIcon _obj icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    result <- gtk_icon_theme_has_icon _obj' icon_name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem icon_name'+    return result'++-- method IconTheme::list_contexts+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_list_contexts" gtk_icon_theme_list_contexts :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    IO (Ptr (GList CString))+++iconThemeListContexts ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    m [T.Text]+iconThemeListContexts _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_theme_list_contexts _obj'+    checkUnexpectedReturnNULL "gtk_icon_theme_list_contexts" result+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method IconTheme::list_icons+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_list_icons" gtk_icon_theme_list_icons :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- context : TBasicType TUTF8+    IO (Ptr (GList CString))+++iconThemeListIcons ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- context+    m [T.Text]+iconThemeListIcons _obj context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeContext <- case context of+        Nothing -> return nullPtr+        Just jContext -> do+            jContext' <- textToCString jContext+            return jContext'+    result <- gtk_icon_theme_list_icons _obj' maybeContext+    checkUnexpectedReturnNULL "gtk_icon_theme_list_icons" result+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    touchManagedPtr _obj+    freeMem maybeContext+    return result''++-- method IconTheme::load_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_theme_load_icon" gtk_icon_theme_load_icon :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconThemeLoadIcon ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    [IconLookupFlags] ->                    -- flags+    m GdkPixbuf.Pixbuf+iconThemeLoadIcon _obj icon_name size flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gtk_icon_theme_load_icon _obj' icon_name' size flags'+        checkUnexpectedReturnNULL "gtk_icon_theme_load_icon" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        touchManagedPtr _obj+        freeMem icon_name'+        return result'+     ) (do+        freeMem icon_name'+     )++-- method IconTheme::load_icon_for_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_theme_load_icon_for_scale" gtk_icon_theme_load_icon_for_scale :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- scale : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.Pixbuf)+++iconThemeLoadIconForScale ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    Int32 ->                                -- scale+    [IconLookupFlags] ->                    -- flags+    m GdkPixbuf.Pixbuf+iconThemeLoadIconForScale _obj icon_name size scale flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gtk_icon_theme_load_icon_for_scale _obj' icon_name' size scale flags'+        checkUnexpectedReturnNULL "gtk_icon_theme_load_icon_for_scale" result+        result' <- (wrapObject GdkPixbuf.Pixbuf) result+        touchManagedPtr _obj+        freeMem icon_name'+        return result'+     ) (do+        freeMem icon_name'+     )++-- method IconTheme::load_surface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "for_window", argType = TInterface "Gdk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_icon_theme_load_surface" gtk_icon_theme_load_surface :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- scale : TBasicType TInt32+    Ptr Gdk.Window ->                       -- for_window : TInterface "Gdk" "Window"+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Cairo.Surface)+++iconThemeLoadSurface ::+    (MonadIO m, IconThemeK a, Gdk.WindowK b) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    Int32 ->                                -- scale+    Maybe (b) ->                            -- for_window+    [IconLookupFlags] ->                    -- flags+    m Cairo.Surface+iconThemeLoadSurface _obj icon_name size scale for_window flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    maybeFor_window <- case for_window of+        Nothing -> return nullPtr+        Just jFor_window -> do+            let jFor_window' = unsafeManagedPtrCastPtr jFor_window+            return jFor_window'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gtk_icon_theme_load_surface _obj' icon_name' size scale maybeFor_window flags'+        checkUnexpectedReturnNULL "gtk_icon_theme_load_surface" result+        result' <- (wrapBoxed Cairo.Surface) result+        touchManagedPtr _obj+        whenJust for_window touchManagedPtr+        freeMem icon_name'+        return result'+     ) (do+        freeMem icon_name'+     )++-- method IconTheme::lookup_by_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", 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},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", 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},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_lookup_by_gicon" gtk_icon_theme_lookup_by_gicon :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    Int32 ->                                -- size : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeLookupByGicon ::+    (MonadIO m, IconThemeK a, Gio.IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    Int32 ->                                -- size+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeLookupByGicon _obj icon size flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_lookup_by_gicon _obj' icon' size flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_lookup_by_gicon" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    touchManagedPtr icon+    return result'++-- method IconTheme::lookup_by_gicon_for_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", 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},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", 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},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_lookup_by_gicon_for_scale" gtk_icon_theme_lookup_by_gicon_for_scale :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- scale : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeLookupByGiconForScale ::+    (MonadIO m, IconThemeK a, Gio.IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    Int32 ->                                -- size+    Int32 ->                                -- scale+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeLookupByGiconForScale _obj icon size scale flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_lookup_by_gicon_for_scale _obj' icon' size scale flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_lookup_by_gicon_for_scale" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    touchManagedPtr icon+    return result'++-- method IconTheme::lookup_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_lookup_icon" gtk_icon_theme_lookup_icon :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeLookupIcon ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeLookupIcon _obj icon_name size flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_lookup_icon _obj' icon_name' size flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_lookup_icon" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    freeMem icon_name'+    return result'++-- method IconTheme::lookup_icon_for_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "scale", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "IconLookupFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_lookup_icon_for_scale" gtk_icon_theme_lookup_icon_for_scale :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    Int32 ->                                -- scale : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "Gtk" "IconLookupFlags"+    IO (Ptr IconInfo)+++iconThemeLookupIconForScale ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    Int32 ->                                -- scale+    [IconLookupFlags] ->                    -- flags+    m IconInfo+iconThemeLookupIconForScale _obj icon_name size scale flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    let flags' = gflagsToWord flags+    result <- gtk_icon_theme_lookup_icon_for_scale _obj' icon_name' size scale flags'+    checkUnexpectedReturnNULL "gtk_icon_theme_lookup_icon_for_scale" result+    result' <- (wrapObject IconInfo) result+    touchManagedPtr _obj+    freeMem icon_name'+    return result'++-- method IconTheme::prepend_search_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_prepend_search_path" gtk_icon_theme_prepend_search_path :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- path : TBasicType TFileName+    IO ()+++iconThemePrependSearchPath ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- path+    m ()+iconThemePrependSearchPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- stringToCString path+    gtk_icon_theme_prepend_search_path _obj' path'+    touchManagedPtr _obj+    freeMem path'+    return ()++-- method IconTheme::rescan_if_needed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_rescan_if_needed" gtk_icon_theme_rescan_if_needed :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    IO CInt+++iconThemeRescanIfNeeded ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    m Bool+iconThemeRescanIfNeeded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_theme_rescan_if_needed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IconTheme::set_custom_theme+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "theme_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "theme_name", 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 "gtk_icon_theme_set_custom_theme" gtk_icon_theme_set_custom_theme :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    CString ->                              -- theme_name : TBasicType TUTF8+    IO ()+++iconThemeSetCustomTheme ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- theme_name+    m ()+iconThemeSetCustomTheme _obj theme_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeTheme_name <- case theme_name of+        Nothing -> return nullPtr+        Just jTheme_name -> do+            jTheme_name' <- textToCString jTheme_name+            return jTheme_name'+    gtk_icon_theme_set_custom_theme _obj' maybeTheme_name+    touchManagedPtr _obj+    freeMem maybeTheme_name+    return ()++-- method IconTheme::set_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_set_screen" gtk_icon_theme_set_screen :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO ()+++iconThemeSetScreen ::+    (MonadIO m, IconThemeK a, Gdk.ScreenK b) =>+    a ->                                    -- _obj+    b ->                                    -- screen+    m ()+iconThemeSetScreen _obj screen = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let screen' = unsafeManagedPtrCastPtr screen+    gtk_icon_theme_set_screen _obj' screen'+    touchManagedPtr _obj+    touchManagedPtr screen+    return ()++-- method IconTheme::set_search_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TCArray False (-1) 2 (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_elements", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_elements", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconTheme", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TCArray False (-1) 2 (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_set_search_path" gtk_icon_theme_set_search_path :: +    Ptr IconTheme ->                        -- _obj : TInterface "Gtk" "IconTheme"+    Ptr CString ->                          -- path : TCArray False (-1) 2 (TBasicType TFileName)+    Int32 ->                                -- n_elements : TBasicType TInt32+    IO ()+++iconThemeSetSearchPath ::+    (MonadIO m, IconThemeK a) =>+    a ->                                    -- _obj+    [[Char]] ->                             -- path+    m ()+iconThemeSetSearchPath _obj path = liftIO $ do+    let n_elements = fromIntegral $ length path+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- packFileNameArray path+    gtk_icon_theme_set_search_path _obj' path' n_elements+    touchManagedPtr _obj+    (mapCArrayWithLength n_elements) freeMem path'+    freeMem path'+    return ()++-- method IconTheme::add_builtin_icon+-- method type : MemberFunction+-- Args : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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 = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_add_builtin_icon" gtk_icon_theme_add_builtin_icon :: +    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()++{-# DEPRECATED iconThemeAddBuiltinIcon ["(Since version 3.14)","Use gtk_icon_theme_add_resource_path()","    to add application-specific icons to the icon theme."]#-}+iconThemeAddBuiltinIcon ::+    (MonadIO m, GdkPixbuf.PixbufK a) =>+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    a ->                                    -- pixbuf+    m ()+iconThemeAddBuiltinIcon icon_name size pixbuf = liftIO $ do+    icon_name' <- textToCString icon_name+    let pixbuf' = unsafeManagedPtrCastPtr pixbuf+    gtk_icon_theme_add_builtin_icon icon_name' size pixbuf'+    touchManagedPtr pixbuf+    freeMem icon_name'+    return ()++-- method IconTheme::get_default+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IconTheme"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_get_default" gtk_icon_theme_get_default :: +    IO (Ptr IconTheme)+++iconThemeGetDefault ::+    (MonadIO m) =>+    m IconTheme+iconThemeGetDefault  = liftIO $ do+    result <- gtk_icon_theme_get_default+    checkUnexpectedReturnNULL "gtk_icon_theme_get_default" result+    result' <- (newObject IconTheme) result+    return result'++-- method IconTheme::get_for_screen+-- method type : MemberFunction+-- Args : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconTheme"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_theme_get_for_screen" gtk_icon_theme_get_for_screen :: +    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO (Ptr IconTheme)+++iconThemeGetForScreen ::+    (MonadIO m, Gdk.ScreenK a) =>+    a ->                                    -- screen+    m IconTheme+iconThemeGetForScreen screen = liftIO $ do+    let screen' = unsafeManagedPtrCastPtr screen+    result <- gtk_icon_theme_get_for_screen screen'+    checkUnexpectedReturnNULL "gtk_icon_theme_get_for_screen" result+    result' <- (newObject IconTheme) result+    touchManagedPtr screen+    return result'++
+ GI/Gtk/Objects/IconTheme.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.IconTheme where++import Prelude ()+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 IconTheme = IconTheme (ForeignPtr IconTheme)+instance GObject IconTheme where+class GObject o => IconThemeK o+instance (GObject o, IsDescendantOf IconTheme o) => IconThemeK o+data IconThemeChangedSignalInfo
+ GI/Gtk/Objects/IconView.hs view
@@ -0,0 +1,3144 @@++{- |+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.Gtk.Objects.IconView+    ( ++-- * Exported types+    IconView(..)                            ,+    IconViewK                               ,+    toIconView                              ,+    noIconView                              ,+++ -- * Methods+-- ** iconViewConvertWidgetToBinWindowCoords+    iconViewConvertWidgetToBinWindowCoords  ,+++-- ** iconViewCreateDragIcon+    iconViewCreateDragIcon                  ,+++-- ** iconViewEnableModelDragDest+    iconViewEnableModelDragDest             ,+++-- ** iconViewEnableModelDragSource+    iconViewEnableModelDragSource           ,+++-- ** iconViewGetActivateOnSingleClick+    iconViewGetActivateOnSingleClick        ,+++-- ** iconViewGetCellRect+    iconViewGetCellRect                     ,+++-- ** iconViewGetColumnSpacing+    iconViewGetColumnSpacing                ,+++-- ** iconViewGetColumns+    iconViewGetColumns                      ,+++-- ** iconViewGetCursor+    iconViewGetCursor                       ,+++-- ** iconViewGetDestItemAtPos+    iconViewGetDestItemAtPos                ,+++-- ** iconViewGetDragDestItem+    iconViewGetDragDestItem                 ,+++-- ** iconViewGetItemAtPos+    iconViewGetItemAtPos                    ,+++-- ** iconViewGetItemColumn+    iconViewGetItemColumn                   ,+++-- ** iconViewGetItemOrientation+    iconViewGetItemOrientation              ,+++-- ** iconViewGetItemPadding+    iconViewGetItemPadding                  ,+++-- ** iconViewGetItemRow+    iconViewGetItemRow                      ,+++-- ** iconViewGetItemWidth+    iconViewGetItemWidth                    ,+++-- ** iconViewGetMargin+    iconViewGetMargin                       ,+++-- ** iconViewGetMarkupColumn+    iconViewGetMarkupColumn                 ,+++-- ** iconViewGetModel+    iconViewGetModel                        ,+++-- ** iconViewGetPathAtPos+    iconViewGetPathAtPos                    ,+++-- ** iconViewGetPixbufColumn+    iconViewGetPixbufColumn                 ,+++-- ** iconViewGetReorderable+    iconViewGetReorderable                  ,+++-- ** iconViewGetRowSpacing+    iconViewGetRowSpacing                   ,+++-- ** iconViewGetSelectedItems+    iconViewGetSelectedItems                ,+++-- ** iconViewGetSelectionMode+    iconViewGetSelectionMode                ,+++-- ** iconViewGetSpacing+    iconViewGetSpacing                      ,+++-- ** iconViewGetTextColumn+    iconViewGetTextColumn                   ,+++-- ** iconViewGetTooltipColumn+    iconViewGetTooltipColumn                ,+++-- ** iconViewGetTooltipContext+    iconViewGetTooltipContext               ,+++-- ** iconViewGetVisibleRange+    iconViewGetVisibleRange                 ,+++-- ** iconViewItemActivated+    iconViewItemActivated                   ,+++-- ** iconViewNew+    iconViewNew                             ,+++-- ** iconViewNewWithArea+    iconViewNewWithArea                     ,+++-- ** iconViewNewWithModel+    iconViewNewWithModel                    ,+++-- ** iconViewPathIsSelected+    iconViewPathIsSelected                  ,+++-- ** iconViewScrollToPath+    iconViewScrollToPath                    ,+++-- ** iconViewSelectAll+    iconViewSelectAll                       ,+++-- ** iconViewSelectPath+    iconViewSelectPath                      ,+++-- ** iconViewSelectedForeach+    iconViewSelectedForeach                 ,+++-- ** iconViewSetActivateOnSingleClick+    iconViewSetActivateOnSingleClick        ,+++-- ** iconViewSetColumnSpacing+    iconViewSetColumnSpacing                ,+++-- ** iconViewSetColumns+    iconViewSetColumns                      ,+++-- ** iconViewSetCursor+    iconViewSetCursor                       ,+++-- ** iconViewSetDragDestItem+    iconViewSetDragDestItem                 ,+++-- ** iconViewSetItemOrientation+    iconViewSetItemOrientation              ,+++-- ** iconViewSetItemPadding+    iconViewSetItemPadding                  ,+++-- ** iconViewSetItemWidth+    iconViewSetItemWidth                    ,+++-- ** iconViewSetMargin+    iconViewSetMargin                       ,+++-- ** iconViewSetMarkupColumn+    iconViewSetMarkupColumn                 ,+++-- ** iconViewSetModel+    iconViewSetModel                        ,+++-- ** iconViewSetPixbufColumn+    iconViewSetPixbufColumn                 ,+++-- ** iconViewSetReorderable+    iconViewSetReorderable                  ,+++-- ** iconViewSetRowSpacing+    iconViewSetRowSpacing                   ,+++-- ** iconViewSetSelectionMode+    iconViewSetSelectionMode                ,+++-- ** iconViewSetSpacing+    iconViewSetSpacing                      ,+++-- ** iconViewSetTextColumn+    iconViewSetTextColumn                   ,+++-- ** iconViewSetTooltipCell+    iconViewSetTooltipCell                  ,+++-- ** iconViewSetTooltipColumn+    iconViewSetTooltipColumn                ,+++-- ** iconViewSetTooltipItem+    iconViewSetTooltipItem                  ,+++-- ** iconViewUnselectAll+    iconViewUnselectAll                     ,+++-- ** iconViewUnselectPath+    iconViewUnselectPath                    ,+++-- ** iconViewUnsetModelDragDest+    iconViewUnsetModelDragDest              ,+++-- ** iconViewUnsetModelDragSource+    iconViewUnsetModelDragSource            ,+++++ -- * Properties+-- ** ActivateOnSingleClick+    IconViewActivateOnSingleClickPropertyInfo,+    constructIconViewActivateOnSingleClick  ,+    getIconViewActivateOnSingleClick        ,+    setIconViewActivateOnSingleClick        ,+++-- ** CellArea+    IconViewCellAreaPropertyInfo            ,+    constructIconViewCellArea               ,+    getIconViewCellArea                     ,+++-- ** ColumnSpacing+    IconViewColumnSpacingPropertyInfo       ,+    constructIconViewColumnSpacing          ,+    getIconViewColumnSpacing                ,+    setIconViewColumnSpacing                ,+++-- ** Columns+    IconViewColumnsPropertyInfo             ,+    constructIconViewColumns                ,+    getIconViewColumns                      ,+    setIconViewColumns                      ,+++-- ** ItemOrientation+    IconViewItemOrientationPropertyInfo     ,+    constructIconViewItemOrientation        ,+    getIconViewItemOrientation              ,+    setIconViewItemOrientation              ,+++-- ** ItemPadding+    IconViewItemPaddingPropertyInfo         ,+    constructIconViewItemPadding            ,+    getIconViewItemPadding                  ,+    setIconViewItemPadding                  ,+++-- ** ItemWidth+    IconViewItemWidthPropertyInfo           ,+    constructIconViewItemWidth              ,+    getIconViewItemWidth                    ,+    setIconViewItemWidth                    ,+++-- ** Margin+    IconViewMarginPropertyInfo              ,+    constructIconViewMargin                 ,+    getIconViewMargin                       ,+    setIconViewMargin                       ,+++-- ** MarkupColumn+    IconViewMarkupColumnPropertyInfo        ,+    constructIconViewMarkupColumn           ,+    getIconViewMarkupColumn                 ,+    setIconViewMarkupColumn                 ,+++-- ** Model+    IconViewModelPropertyInfo               ,+    constructIconViewModel                  ,+    getIconViewModel                        ,+    setIconViewModel                        ,+++-- ** PixbufColumn+    IconViewPixbufColumnPropertyInfo        ,+    constructIconViewPixbufColumn           ,+    getIconViewPixbufColumn                 ,+    setIconViewPixbufColumn                 ,+++-- ** Reorderable+    IconViewReorderablePropertyInfo         ,+    constructIconViewReorderable            ,+    getIconViewReorderable                  ,+    setIconViewReorderable                  ,+++-- ** RowSpacing+    IconViewRowSpacingPropertyInfo          ,+    constructIconViewRowSpacing             ,+    getIconViewRowSpacing                   ,+    setIconViewRowSpacing                   ,+++-- ** SelectionMode+    IconViewSelectionModePropertyInfo       ,+    constructIconViewSelectionMode          ,+    getIconViewSelectionMode                ,+    setIconViewSelectionMode                ,+++-- ** Spacing+    IconViewSpacingPropertyInfo             ,+    constructIconViewSpacing                ,+    getIconViewSpacing                      ,+    setIconViewSpacing                      ,+++-- ** TextColumn+    IconViewTextColumnPropertyInfo          ,+    constructIconViewTextColumn             ,+    getIconViewTextColumn                   ,+    setIconViewTextColumn                   ,+++-- ** TooltipColumn+    IconViewTooltipColumnPropertyInfo       ,+    constructIconViewTooltipColumn          ,+    getIconViewTooltipColumn                ,+    setIconViewTooltipColumn                ,+++++ -- * Signals+-- ** ActivateCursorItem+    IconViewActivateCursorItemCallback      ,+    IconViewActivateCursorItemCallbackC     ,+    IconViewActivateCursorItemSignalInfo    ,+    afterIconViewActivateCursorItem         ,+    iconViewActivateCursorItemCallbackWrapper,+    iconViewActivateCursorItemClosure       ,+    mkIconViewActivateCursorItemCallback    ,+    noIconViewActivateCursorItemCallback    ,+    onIconViewActivateCursorItem            ,+++-- ** ItemActivated+    IconViewItemActivatedCallback           ,+    IconViewItemActivatedCallbackC          ,+    IconViewItemActivatedSignalInfo         ,+    afterIconViewItemActivated              ,+    iconViewItemActivatedCallbackWrapper    ,+    iconViewItemActivatedClosure            ,+    mkIconViewItemActivatedCallback         ,+    noIconViewItemActivatedCallback         ,+    onIconViewItemActivated                 ,+++-- ** MoveCursor+    IconViewMoveCursorCallback              ,+    IconViewMoveCursorCallbackC             ,+    IconViewMoveCursorSignalInfo            ,+    afterIconViewMoveCursor                 ,+    iconViewMoveCursorCallbackWrapper       ,+    iconViewMoveCursorClosure               ,+    mkIconViewMoveCursorCallback            ,+    noIconViewMoveCursorCallback            ,+    onIconViewMoveCursor                    ,+++-- ** SelectAll+    IconViewSelectAllCallback               ,+    IconViewSelectAllCallbackC              ,+    IconViewSelectAllSignalInfo             ,+    afterIconViewSelectAll                  ,+    iconViewSelectAllCallbackWrapper        ,+    iconViewSelectAllClosure                ,+    mkIconViewSelectAllCallback             ,+    noIconViewSelectAllCallback             ,+    onIconViewSelectAll                     ,+++-- ** SelectCursorItem+    IconViewSelectCursorItemCallback        ,+    IconViewSelectCursorItemCallbackC       ,+    IconViewSelectCursorItemSignalInfo      ,+    afterIconViewSelectCursorItem           ,+    iconViewSelectCursorItemCallbackWrapper ,+    iconViewSelectCursorItemClosure         ,+    mkIconViewSelectCursorItemCallback      ,+    noIconViewSelectCursorItemCallback      ,+    onIconViewSelectCursorItem              ,+++-- ** SelectionChanged+    IconViewSelectionChangedCallback        ,+    IconViewSelectionChangedCallbackC       ,+    IconViewSelectionChangedSignalInfo      ,+    afterIconViewSelectionChanged           ,+    iconViewSelectionChangedCallbackWrapper ,+    iconViewSelectionChangedClosure         ,+    mkIconViewSelectionChangedCallback      ,+    noIconViewSelectionChangedCallback      ,+    onIconViewSelectionChanged              ,+++-- ** ToggleCursorItem+    IconViewToggleCursorItemCallback        ,+    IconViewToggleCursorItemCallbackC       ,+    IconViewToggleCursorItemSignalInfo      ,+    afterIconViewToggleCursorItem           ,+    iconViewToggleCursorItemCallbackWrapper ,+    iconViewToggleCursorItemClosure         ,+    mkIconViewToggleCursorItemCallback      ,+    noIconViewToggleCursorItemCallback      ,+    onIconViewToggleCursorItem              ,+++-- ** UnselectAll+    IconViewUnselectAllCallback             ,+    IconViewUnselectAllCallbackC            ,+    IconViewUnselectAllSignalInfo           ,+    afterIconViewUnselectAll                ,+    iconViewUnselectAllCallbackWrapper      ,+    iconViewUnselectAllClosure              ,+    mkIconViewUnselectAllCallback           ,+    noIconViewUnselectAllCallback           ,+    onIconViewUnselectAll                   ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Cairo as Cairo++newtype IconView = IconView (ForeignPtr IconView)+foreign import ccall "gtk_icon_view_get_type"+    c_gtk_icon_view_get_type :: IO GType++type instance ParentTypes IconView = IconViewParentTypes+type IconViewParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, CellLayout, Scrollable]++instance GObject IconView where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_icon_view_get_type+    ++class GObject o => IconViewK o+instance (GObject o, IsDescendantOf IconView o) => IconViewK o++toIconView :: IconViewK o => o -> IO IconView+toIconView = unsafeCastTo IconView++noIconView :: Maybe IconView+noIconView = Nothing++-- signal IconView::activate-cursor-item+type IconViewActivateCursorItemCallback =+    IO Bool++noIconViewActivateCursorItemCallback :: Maybe IconViewActivateCursorItemCallback+noIconViewActivateCursorItemCallback = Nothing++type IconViewActivateCursorItemCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkIconViewActivateCursorItemCallback :: IconViewActivateCursorItemCallbackC -> IO (FunPtr IconViewActivateCursorItemCallbackC)++iconViewActivateCursorItemClosure :: IconViewActivateCursorItemCallback -> IO Closure+iconViewActivateCursorItemClosure cb = newCClosure =<< mkIconViewActivateCursorItemCallback wrapped+    where wrapped = iconViewActivateCursorItemCallbackWrapper cb++iconViewActivateCursorItemCallbackWrapper ::+    IconViewActivateCursorItemCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+iconViewActivateCursorItemCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onIconViewActivateCursorItem :: (GObject a, MonadIO m) => a -> IconViewActivateCursorItemCallback -> m SignalHandlerId+onIconViewActivateCursorItem obj cb = liftIO $ connectIconViewActivateCursorItem obj cb SignalConnectBefore+afterIconViewActivateCursorItem :: (GObject a, MonadIO m) => a -> IconViewActivateCursorItemCallback -> m SignalHandlerId+afterIconViewActivateCursorItem obj cb = connectIconViewActivateCursorItem obj cb SignalConnectAfter++connectIconViewActivateCursorItem :: (GObject a, MonadIO m) =>+                                     a -> IconViewActivateCursorItemCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewActivateCursorItem obj cb after = liftIO $ do+    cb' <- mkIconViewActivateCursorItemCallback (iconViewActivateCursorItemCallbackWrapper cb)+    connectSignalFunPtr obj "activate-cursor-item" cb' after++-- signal IconView::item-activated+type IconViewItemActivatedCallback =+    TreePath ->+    IO ()++noIconViewItemActivatedCallback :: Maybe IconViewItemActivatedCallback+noIconViewItemActivatedCallback = Nothing++type IconViewItemActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr TreePath ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewItemActivatedCallback :: IconViewItemActivatedCallbackC -> IO (FunPtr IconViewItemActivatedCallbackC)++iconViewItemActivatedClosure :: IconViewItemActivatedCallback -> IO Closure+iconViewItemActivatedClosure cb = newCClosure =<< mkIconViewItemActivatedCallback wrapped+    where wrapped = iconViewItemActivatedCallbackWrapper cb++iconViewItemActivatedCallbackWrapper ::+    IconViewItemActivatedCallback ->+    Ptr () ->+    Ptr TreePath ->+    Ptr () ->+    IO ()+iconViewItemActivatedCallbackWrapper _cb _ path _ = do+    path' <- (newBoxed TreePath) path+    _cb  path'++onIconViewItemActivated :: (GObject a, MonadIO m) => a -> IconViewItemActivatedCallback -> m SignalHandlerId+onIconViewItemActivated obj cb = liftIO $ connectIconViewItemActivated obj cb SignalConnectBefore+afterIconViewItemActivated :: (GObject a, MonadIO m) => a -> IconViewItemActivatedCallback -> m SignalHandlerId+afterIconViewItemActivated obj cb = connectIconViewItemActivated obj cb SignalConnectAfter++connectIconViewItemActivated :: (GObject a, MonadIO m) =>+                                a -> IconViewItemActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewItemActivated obj cb after = liftIO $ do+    cb' <- mkIconViewItemActivatedCallback (iconViewItemActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "item-activated" cb' after++-- signal IconView::move-cursor+type IconViewMoveCursorCallback =+    MovementStep ->+    Int32 ->+    IO Bool++noIconViewMoveCursorCallback :: Maybe IconViewMoveCursorCallback+noIconViewMoveCursorCallback = Nothing++type IconViewMoveCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkIconViewMoveCursorCallback :: IconViewMoveCursorCallbackC -> IO (FunPtr IconViewMoveCursorCallbackC)++iconViewMoveCursorClosure :: IconViewMoveCursorCallback -> IO Closure+iconViewMoveCursorClosure cb = newCClosure =<< mkIconViewMoveCursorCallback wrapped+    where wrapped = iconViewMoveCursorCallbackWrapper cb++iconViewMoveCursorCallbackWrapper ::+    IconViewMoveCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    Ptr () ->+    IO CInt+iconViewMoveCursorCallbackWrapper _cb _ step count _ = do+    let step' = (toEnum . fromIntegral) step+    result <- _cb  step' count+    let result' = (fromIntegral . fromEnum) result+    return result'++onIconViewMoveCursor :: (GObject a, MonadIO m) => a -> IconViewMoveCursorCallback -> m SignalHandlerId+onIconViewMoveCursor obj cb = liftIO $ connectIconViewMoveCursor obj cb SignalConnectBefore+afterIconViewMoveCursor :: (GObject a, MonadIO m) => a -> IconViewMoveCursorCallback -> m SignalHandlerId+afterIconViewMoveCursor obj cb = connectIconViewMoveCursor obj cb SignalConnectAfter++connectIconViewMoveCursor :: (GObject a, MonadIO m) =>+                             a -> IconViewMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewMoveCursor obj cb after = liftIO $ do+    cb' <- mkIconViewMoveCursorCallback (iconViewMoveCursorCallbackWrapper cb)+    connectSignalFunPtr obj "move-cursor" cb' after++-- signal IconView::select-all+type IconViewSelectAllCallback =+    IO ()++noIconViewSelectAllCallback :: Maybe IconViewSelectAllCallback+noIconViewSelectAllCallback = Nothing++type IconViewSelectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewSelectAllCallback :: IconViewSelectAllCallbackC -> IO (FunPtr IconViewSelectAllCallbackC)++iconViewSelectAllClosure :: IconViewSelectAllCallback -> IO Closure+iconViewSelectAllClosure cb = newCClosure =<< mkIconViewSelectAllCallback wrapped+    where wrapped = iconViewSelectAllCallbackWrapper cb++iconViewSelectAllCallbackWrapper ::+    IconViewSelectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconViewSelectAllCallbackWrapper _cb _ _ = do+    _cb ++onIconViewSelectAll :: (GObject a, MonadIO m) => a -> IconViewSelectAllCallback -> m SignalHandlerId+onIconViewSelectAll obj cb = liftIO $ connectIconViewSelectAll obj cb SignalConnectBefore+afterIconViewSelectAll :: (GObject a, MonadIO m) => a -> IconViewSelectAllCallback -> m SignalHandlerId+afterIconViewSelectAll obj cb = connectIconViewSelectAll obj cb SignalConnectAfter++connectIconViewSelectAll :: (GObject a, MonadIO m) =>+                            a -> IconViewSelectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewSelectAll obj cb after = liftIO $ do+    cb' <- mkIconViewSelectAllCallback (iconViewSelectAllCallbackWrapper cb)+    connectSignalFunPtr obj "select-all" cb' after++-- signal IconView::select-cursor-item+type IconViewSelectCursorItemCallback =+    IO ()++noIconViewSelectCursorItemCallback :: Maybe IconViewSelectCursorItemCallback+noIconViewSelectCursorItemCallback = Nothing++type IconViewSelectCursorItemCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewSelectCursorItemCallback :: IconViewSelectCursorItemCallbackC -> IO (FunPtr IconViewSelectCursorItemCallbackC)++iconViewSelectCursorItemClosure :: IconViewSelectCursorItemCallback -> IO Closure+iconViewSelectCursorItemClosure cb = newCClosure =<< mkIconViewSelectCursorItemCallback wrapped+    where wrapped = iconViewSelectCursorItemCallbackWrapper cb++iconViewSelectCursorItemCallbackWrapper ::+    IconViewSelectCursorItemCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconViewSelectCursorItemCallbackWrapper _cb _ _ = do+    _cb ++onIconViewSelectCursorItem :: (GObject a, MonadIO m) => a -> IconViewSelectCursorItemCallback -> m SignalHandlerId+onIconViewSelectCursorItem obj cb = liftIO $ connectIconViewSelectCursorItem obj cb SignalConnectBefore+afterIconViewSelectCursorItem :: (GObject a, MonadIO m) => a -> IconViewSelectCursorItemCallback -> m SignalHandlerId+afterIconViewSelectCursorItem obj cb = connectIconViewSelectCursorItem obj cb SignalConnectAfter++connectIconViewSelectCursorItem :: (GObject a, MonadIO m) =>+                                   a -> IconViewSelectCursorItemCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewSelectCursorItem obj cb after = liftIO $ do+    cb' <- mkIconViewSelectCursorItemCallback (iconViewSelectCursorItemCallbackWrapper cb)+    connectSignalFunPtr obj "select-cursor-item" cb' after++-- signal IconView::selection-changed+type IconViewSelectionChangedCallback =+    IO ()++noIconViewSelectionChangedCallback :: Maybe IconViewSelectionChangedCallback+noIconViewSelectionChangedCallback = Nothing++type IconViewSelectionChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewSelectionChangedCallback :: IconViewSelectionChangedCallbackC -> IO (FunPtr IconViewSelectionChangedCallbackC)++iconViewSelectionChangedClosure :: IconViewSelectionChangedCallback -> IO Closure+iconViewSelectionChangedClosure cb = newCClosure =<< mkIconViewSelectionChangedCallback wrapped+    where wrapped = iconViewSelectionChangedCallbackWrapper cb++iconViewSelectionChangedCallbackWrapper ::+    IconViewSelectionChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconViewSelectionChangedCallbackWrapper _cb _ _ = do+    _cb ++onIconViewSelectionChanged :: (GObject a, MonadIO m) => a -> IconViewSelectionChangedCallback -> m SignalHandlerId+onIconViewSelectionChanged obj cb = liftIO $ connectIconViewSelectionChanged obj cb SignalConnectBefore+afterIconViewSelectionChanged :: (GObject a, MonadIO m) => a -> IconViewSelectionChangedCallback -> m SignalHandlerId+afterIconViewSelectionChanged obj cb = connectIconViewSelectionChanged obj cb SignalConnectAfter++connectIconViewSelectionChanged :: (GObject a, MonadIO m) =>+                                   a -> IconViewSelectionChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewSelectionChanged obj cb after = liftIO $ do+    cb' <- mkIconViewSelectionChangedCallback (iconViewSelectionChangedCallbackWrapper cb)+    connectSignalFunPtr obj "selection-changed" cb' after++-- signal IconView::toggle-cursor-item+type IconViewToggleCursorItemCallback =+    IO ()++noIconViewToggleCursorItemCallback :: Maybe IconViewToggleCursorItemCallback+noIconViewToggleCursorItemCallback = Nothing++type IconViewToggleCursorItemCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewToggleCursorItemCallback :: IconViewToggleCursorItemCallbackC -> IO (FunPtr IconViewToggleCursorItemCallbackC)++iconViewToggleCursorItemClosure :: IconViewToggleCursorItemCallback -> IO Closure+iconViewToggleCursorItemClosure cb = newCClosure =<< mkIconViewToggleCursorItemCallback wrapped+    where wrapped = iconViewToggleCursorItemCallbackWrapper cb++iconViewToggleCursorItemCallbackWrapper ::+    IconViewToggleCursorItemCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconViewToggleCursorItemCallbackWrapper _cb _ _ = do+    _cb ++onIconViewToggleCursorItem :: (GObject a, MonadIO m) => a -> IconViewToggleCursorItemCallback -> m SignalHandlerId+onIconViewToggleCursorItem obj cb = liftIO $ connectIconViewToggleCursorItem obj cb SignalConnectBefore+afterIconViewToggleCursorItem :: (GObject a, MonadIO m) => a -> IconViewToggleCursorItemCallback -> m SignalHandlerId+afterIconViewToggleCursorItem obj cb = connectIconViewToggleCursorItem obj cb SignalConnectAfter++connectIconViewToggleCursorItem :: (GObject a, MonadIO m) =>+                                   a -> IconViewToggleCursorItemCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewToggleCursorItem obj cb after = liftIO $ do+    cb' <- mkIconViewToggleCursorItemCallback (iconViewToggleCursorItemCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-cursor-item" cb' after++-- signal IconView::unselect-all+type IconViewUnselectAllCallback =+    IO ()++noIconViewUnselectAllCallback :: Maybe IconViewUnselectAllCallback+noIconViewUnselectAllCallback = Nothing++type IconViewUnselectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkIconViewUnselectAllCallback :: IconViewUnselectAllCallbackC -> IO (FunPtr IconViewUnselectAllCallbackC)++iconViewUnselectAllClosure :: IconViewUnselectAllCallback -> IO Closure+iconViewUnselectAllClosure cb = newCClosure =<< mkIconViewUnselectAllCallback wrapped+    where wrapped = iconViewUnselectAllCallbackWrapper cb++iconViewUnselectAllCallbackWrapper ::+    IconViewUnselectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+iconViewUnselectAllCallbackWrapper _cb _ _ = do+    _cb ++onIconViewUnselectAll :: (GObject a, MonadIO m) => a -> IconViewUnselectAllCallback -> m SignalHandlerId+onIconViewUnselectAll obj cb = liftIO $ connectIconViewUnselectAll obj cb SignalConnectBefore+afterIconViewUnselectAll :: (GObject a, MonadIO m) => a -> IconViewUnselectAllCallback -> m SignalHandlerId+afterIconViewUnselectAll obj cb = connectIconViewUnselectAll obj cb SignalConnectAfter++connectIconViewUnselectAll :: (GObject a, MonadIO m) =>+                              a -> IconViewUnselectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectIconViewUnselectAll obj cb after = liftIO $ do+    cb' <- mkIconViewUnselectAllCallback (iconViewUnselectAllCallbackWrapper cb)+    connectSignalFunPtr obj "unselect-all" cb' after++-- VVV Prop "activate-on-single-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewActivateOnSingleClick :: (MonadIO m, IconViewK o) => o -> m Bool+getIconViewActivateOnSingleClick obj = liftIO $ getObjectPropertyBool obj "activate-on-single-click"++setIconViewActivateOnSingleClick :: (MonadIO m, IconViewK o) => o -> Bool -> m ()+setIconViewActivateOnSingleClick obj val = liftIO $ setObjectPropertyBool obj "activate-on-single-click" val++constructIconViewActivateOnSingleClick :: Bool -> IO ([Char], GValue)+constructIconViewActivateOnSingleClick val = constructObjectPropertyBool "activate-on-single-click" val++data IconViewActivateOnSingleClickPropertyInfo+instance AttrInfo IconViewActivateOnSingleClickPropertyInfo where+    type AttrAllowedOps IconViewActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewActivateOnSingleClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint IconViewActivateOnSingleClickPropertyInfo = IconViewK+    type AttrGetType IconViewActivateOnSingleClickPropertyInfo = Bool+    type AttrLabel IconViewActivateOnSingleClickPropertyInfo = "IconView::activate-on-single-click"+    attrGet _ = getIconViewActivateOnSingleClick+    attrSet _ = setIconViewActivateOnSingleClick+    attrConstruct _ = constructIconViewActivateOnSingleClick++-- VVV Prop "cell-area"+   -- Type: TInterface "Gtk" "CellArea"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getIconViewCellArea :: (MonadIO m, IconViewK o) => o -> m CellArea+getIconViewCellArea obj = liftIO $ getObjectPropertyObject obj "cell-area" CellArea++constructIconViewCellArea :: (CellAreaK a) => a -> IO ([Char], GValue)+constructIconViewCellArea val = constructObjectPropertyObject "cell-area" val++data IconViewCellAreaPropertyInfo+instance AttrInfo IconViewCellAreaPropertyInfo where+    type AttrAllowedOps IconViewCellAreaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewCellAreaPropertyInfo = CellAreaK+    type AttrBaseTypeConstraint IconViewCellAreaPropertyInfo = IconViewK+    type AttrGetType IconViewCellAreaPropertyInfo = CellArea+    type AttrLabel IconViewCellAreaPropertyInfo = "IconView::cell-area"+    attrGet _ = getIconViewCellArea+    attrSet _ = undefined+    attrConstruct _ = constructIconViewCellArea++-- VVV Prop "column-spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewColumnSpacing :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewColumnSpacing obj = liftIO $ getObjectPropertyCInt obj "column-spacing"++setIconViewColumnSpacing :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewColumnSpacing obj val = liftIO $ setObjectPropertyCInt obj "column-spacing" val++constructIconViewColumnSpacing :: Int32 -> IO ([Char], GValue)+constructIconViewColumnSpacing val = constructObjectPropertyCInt "column-spacing" val++data IconViewColumnSpacingPropertyInfo+instance AttrInfo IconViewColumnSpacingPropertyInfo where+    type AttrAllowedOps IconViewColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewColumnSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewColumnSpacingPropertyInfo = IconViewK+    type AttrGetType IconViewColumnSpacingPropertyInfo = Int32+    type AttrLabel IconViewColumnSpacingPropertyInfo = "IconView::column-spacing"+    attrGet _ = getIconViewColumnSpacing+    attrSet _ = setIconViewColumnSpacing+    attrConstruct _ = constructIconViewColumnSpacing++-- VVV Prop "columns"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewColumns :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewColumns obj = liftIO $ getObjectPropertyCInt obj "columns"++setIconViewColumns :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewColumns obj val = liftIO $ setObjectPropertyCInt obj "columns" val++constructIconViewColumns :: Int32 -> IO ([Char], GValue)+constructIconViewColumns val = constructObjectPropertyCInt "columns" val++data IconViewColumnsPropertyInfo+instance AttrInfo IconViewColumnsPropertyInfo where+    type AttrAllowedOps IconViewColumnsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewColumnsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewColumnsPropertyInfo = IconViewK+    type AttrGetType IconViewColumnsPropertyInfo = Int32+    type AttrLabel IconViewColumnsPropertyInfo = "IconView::columns"+    attrGet _ = getIconViewColumns+    attrSet _ = setIconViewColumns+    attrConstruct _ = constructIconViewColumns++-- VVV Prop "item-orientation"+   -- Type: TInterface "Gtk" "Orientation"+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewItemOrientation :: (MonadIO m, IconViewK o) => o -> m Orientation+getIconViewItemOrientation obj = liftIO $ getObjectPropertyEnum obj "item-orientation"++setIconViewItemOrientation :: (MonadIO m, IconViewK o) => o -> Orientation -> m ()+setIconViewItemOrientation obj val = liftIO $ setObjectPropertyEnum obj "item-orientation" val++constructIconViewItemOrientation :: Orientation -> IO ([Char], GValue)+constructIconViewItemOrientation val = constructObjectPropertyEnum "item-orientation" val++data IconViewItemOrientationPropertyInfo+instance AttrInfo IconViewItemOrientationPropertyInfo where+    type AttrAllowedOps IconViewItemOrientationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewItemOrientationPropertyInfo = (~) Orientation+    type AttrBaseTypeConstraint IconViewItemOrientationPropertyInfo = IconViewK+    type AttrGetType IconViewItemOrientationPropertyInfo = Orientation+    type AttrLabel IconViewItemOrientationPropertyInfo = "IconView::item-orientation"+    attrGet _ = getIconViewItemOrientation+    attrSet _ = setIconViewItemOrientation+    attrConstruct _ = constructIconViewItemOrientation++-- VVV Prop "item-padding"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewItemPadding :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewItemPadding obj = liftIO $ getObjectPropertyCInt obj "item-padding"++setIconViewItemPadding :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewItemPadding obj val = liftIO $ setObjectPropertyCInt obj "item-padding" val++constructIconViewItemPadding :: Int32 -> IO ([Char], GValue)+constructIconViewItemPadding val = constructObjectPropertyCInt "item-padding" val++data IconViewItemPaddingPropertyInfo+instance AttrInfo IconViewItemPaddingPropertyInfo where+    type AttrAllowedOps IconViewItemPaddingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewItemPaddingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewItemPaddingPropertyInfo = IconViewK+    type AttrGetType IconViewItemPaddingPropertyInfo = Int32+    type AttrLabel IconViewItemPaddingPropertyInfo = "IconView::item-padding"+    attrGet _ = getIconViewItemPadding+    attrSet _ = setIconViewItemPadding+    attrConstruct _ = constructIconViewItemPadding++-- VVV Prop "item-width"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewItemWidth :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewItemWidth obj = liftIO $ getObjectPropertyCInt obj "item-width"++setIconViewItemWidth :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewItemWidth obj val = liftIO $ setObjectPropertyCInt obj "item-width" val++constructIconViewItemWidth :: Int32 -> IO ([Char], GValue)+constructIconViewItemWidth val = constructObjectPropertyCInt "item-width" val++data IconViewItemWidthPropertyInfo+instance AttrInfo IconViewItemWidthPropertyInfo where+    type AttrAllowedOps IconViewItemWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewItemWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewItemWidthPropertyInfo = IconViewK+    type AttrGetType IconViewItemWidthPropertyInfo = Int32+    type AttrLabel IconViewItemWidthPropertyInfo = "IconView::item-width"+    attrGet _ = getIconViewItemWidth+    attrSet _ = setIconViewItemWidth+    attrConstruct _ = constructIconViewItemWidth++-- VVV Prop "margin"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewMargin :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewMargin obj = liftIO $ getObjectPropertyCInt obj "margin"++setIconViewMargin :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewMargin obj val = liftIO $ setObjectPropertyCInt obj "margin" val++constructIconViewMargin :: Int32 -> IO ([Char], GValue)+constructIconViewMargin val = constructObjectPropertyCInt "margin" val++data IconViewMarginPropertyInfo+instance AttrInfo IconViewMarginPropertyInfo where+    type AttrAllowedOps IconViewMarginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewMarginPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewMarginPropertyInfo = IconViewK+    type AttrGetType IconViewMarginPropertyInfo = Int32+    type AttrLabel IconViewMarginPropertyInfo = "IconView::margin"+    attrGet _ = getIconViewMargin+    attrSet _ = setIconViewMargin+    attrConstruct _ = constructIconViewMargin++-- VVV Prop "markup-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewMarkupColumn :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewMarkupColumn obj = liftIO $ getObjectPropertyCInt obj "markup-column"++setIconViewMarkupColumn :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewMarkupColumn obj val = liftIO $ setObjectPropertyCInt obj "markup-column" val++constructIconViewMarkupColumn :: Int32 -> IO ([Char], GValue)+constructIconViewMarkupColumn val = constructObjectPropertyCInt "markup-column" val++data IconViewMarkupColumnPropertyInfo+instance AttrInfo IconViewMarkupColumnPropertyInfo where+    type AttrAllowedOps IconViewMarkupColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewMarkupColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewMarkupColumnPropertyInfo = IconViewK+    type AttrGetType IconViewMarkupColumnPropertyInfo = Int32+    type AttrLabel IconViewMarkupColumnPropertyInfo = "IconView::markup-column"+    attrGet _ = getIconViewMarkupColumn+    attrSet _ = setIconViewMarkupColumn+    attrConstruct _ = constructIconViewMarkupColumn++-- VVV Prop "model"+   -- Type: TInterface "Gtk" "TreeModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewModel :: (MonadIO m, IconViewK o) => o -> m TreeModel+getIconViewModel obj = liftIO $ getObjectPropertyObject obj "model" TreeModel++setIconViewModel :: (MonadIO m, IconViewK o, TreeModelK a) => o -> a -> m ()+setIconViewModel obj val = liftIO $ setObjectPropertyObject obj "model" val++constructIconViewModel :: (TreeModelK a) => a -> IO ([Char], GValue)+constructIconViewModel val = constructObjectPropertyObject "model" val++data IconViewModelPropertyInfo+instance AttrInfo IconViewModelPropertyInfo where+    type AttrAllowedOps IconViewModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewModelPropertyInfo = TreeModelK+    type AttrBaseTypeConstraint IconViewModelPropertyInfo = IconViewK+    type AttrGetType IconViewModelPropertyInfo = TreeModel+    type AttrLabel IconViewModelPropertyInfo = "IconView::model"+    attrGet _ = getIconViewModel+    attrSet _ = setIconViewModel+    attrConstruct _ = constructIconViewModel++-- VVV Prop "pixbuf-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewPixbufColumn :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewPixbufColumn obj = liftIO $ getObjectPropertyCInt obj "pixbuf-column"++setIconViewPixbufColumn :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewPixbufColumn obj val = liftIO $ setObjectPropertyCInt obj "pixbuf-column" val++constructIconViewPixbufColumn :: Int32 -> IO ([Char], GValue)+constructIconViewPixbufColumn val = constructObjectPropertyCInt "pixbuf-column" val++data IconViewPixbufColumnPropertyInfo+instance AttrInfo IconViewPixbufColumnPropertyInfo where+    type AttrAllowedOps IconViewPixbufColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewPixbufColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewPixbufColumnPropertyInfo = IconViewK+    type AttrGetType IconViewPixbufColumnPropertyInfo = Int32+    type AttrLabel IconViewPixbufColumnPropertyInfo = "IconView::pixbuf-column"+    attrGet _ = getIconViewPixbufColumn+    attrSet _ = setIconViewPixbufColumn+    attrConstruct _ = constructIconViewPixbufColumn++-- VVV Prop "reorderable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewReorderable :: (MonadIO m, IconViewK o) => o -> m Bool+getIconViewReorderable obj = liftIO $ getObjectPropertyBool obj "reorderable"++setIconViewReorderable :: (MonadIO m, IconViewK o) => o -> Bool -> m ()+setIconViewReorderable obj val = liftIO $ setObjectPropertyBool obj "reorderable" val++constructIconViewReorderable :: Bool -> IO ([Char], GValue)+constructIconViewReorderable val = constructObjectPropertyBool "reorderable" val++data IconViewReorderablePropertyInfo+instance AttrInfo IconViewReorderablePropertyInfo where+    type AttrAllowedOps IconViewReorderablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewReorderablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint IconViewReorderablePropertyInfo = IconViewK+    type AttrGetType IconViewReorderablePropertyInfo = Bool+    type AttrLabel IconViewReorderablePropertyInfo = "IconView::reorderable"+    attrGet _ = getIconViewReorderable+    attrSet _ = setIconViewReorderable+    attrConstruct _ = constructIconViewReorderable++-- VVV Prop "row-spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewRowSpacing :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewRowSpacing obj = liftIO $ getObjectPropertyCInt obj "row-spacing"++setIconViewRowSpacing :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewRowSpacing obj val = liftIO $ setObjectPropertyCInt obj "row-spacing" val++constructIconViewRowSpacing :: Int32 -> IO ([Char], GValue)+constructIconViewRowSpacing val = constructObjectPropertyCInt "row-spacing" val++data IconViewRowSpacingPropertyInfo+instance AttrInfo IconViewRowSpacingPropertyInfo where+    type AttrAllowedOps IconViewRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewRowSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewRowSpacingPropertyInfo = IconViewK+    type AttrGetType IconViewRowSpacingPropertyInfo = Int32+    type AttrLabel IconViewRowSpacingPropertyInfo = "IconView::row-spacing"+    attrGet _ = getIconViewRowSpacing+    attrSet _ = setIconViewRowSpacing+    attrConstruct _ = constructIconViewRowSpacing++-- VVV Prop "selection-mode"+   -- Type: TInterface "Gtk" "SelectionMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewSelectionMode :: (MonadIO m, IconViewK o) => o -> m SelectionMode+getIconViewSelectionMode obj = liftIO $ getObjectPropertyEnum obj "selection-mode"++setIconViewSelectionMode :: (MonadIO m, IconViewK o) => o -> SelectionMode -> m ()+setIconViewSelectionMode obj val = liftIO $ setObjectPropertyEnum obj "selection-mode" val++constructIconViewSelectionMode :: SelectionMode -> IO ([Char], GValue)+constructIconViewSelectionMode val = constructObjectPropertyEnum "selection-mode" val++data IconViewSelectionModePropertyInfo+instance AttrInfo IconViewSelectionModePropertyInfo where+    type AttrAllowedOps IconViewSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewSelectionModePropertyInfo = (~) SelectionMode+    type AttrBaseTypeConstraint IconViewSelectionModePropertyInfo = IconViewK+    type AttrGetType IconViewSelectionModePropertyInfo = SelectionMode+    type AttrLabel IconViewSelectionModePropertyInfo = "IconView::selection-mode"+    attrGet _ = getIconViewSelectionMode+    attrSet _ = setIconViewSelectionMode+    attrConstruct _ = constructIconViewSelectionMode++-- VVV Prop "spacing"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewSpacing :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewSpacing obj = liftIO $ getObjectPropertyCInt obj "spacing"++setIconViewSpacing :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewSpacing obj val = liftIO $ setObjectPropertyCInt obj "spacing" val++constructIconViewSpacing :: Int32 -> IO ([Char], GValue)+constructIconViewSpacing val = constructObjectPropertyCInt "spacing" val++data IconViewSpacingPropertyInfo+instance AttrInfo IconViewSpacingPropertyInfo where+    type AttrAllowedOps IconViewSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewSpacingPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewSpacingPropertyInfo = IconViewK+    type AttrGetType IconViewSpacingPropertyInfo = Int32+    type AttrLabel IconViewSpacingPropertyInfo = "IconView::spacing"+    attrGet _ = getIconViewSpacing+    attrSet _ = setIconViewSpacing+    attrConstruct _ = constructIconViewSpacing++-- VVV Prop "text-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewTextColumn :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewTextColumn obj = liftIO $ getObjectPropertyCInt obj "text-column"++setIconViewTextColumn :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewTextColumn obj val = liftIO $ setObjectPropertyCInt obj "text-column" val++constructIconViewTextColumn :: Int32 -> IO ([Char], GValue)+constructIconViewTextColumn val = constructObjectPropertyCInt "text-column" val++data IconViewTextColumnPropertyInfo+instance AttrInfo IconViewTextColumnPropertyInfo where+    type AttrAllowedOps IconViewTextColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewTextColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewTextColumnPropertyInfo = IconViewK+    type AttrGetType IconViewTextColumnPropertyInfo = Int32+    type AttrLabel IconViewTextColumnPropertyInfo = "IconView::text-column"+    attrGet _ = getIconViewTextColumn+    attrSet _ = setIconViewTextColumn+    attrConstruct _ = constructIconViewTextColumn++-- VVV Prop "tooltip-column"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getIconViewTooltipColumn :: (MonadIO m, IconViewK o) => o -> m Int32+getIconViewTooltipColumn obj = liftIO $ getObjectPropertyCInt obj "tooltip-column"++setIconViewTooltipColumn :: (MonadIO m, IconViewK o) => o -> Int32 -> m ()+setIconViewTooltipColumn obj val = liftIO $ setObjectPropertyCInt obj "tooltip-column" val++constructIconViewTooltipColumn :: Int32 -> IO ([Char], GValue)+constructIconViewTooltipColumn val = constructObjectPropertyCInt "tooltip-column" val++data IconViewTooltipColumnPropertyInfo+instance AttrInfo IconViewTooltipColumnPropertyInfo where+    type AttrAllowedOps IconViewTooltipColumnPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint IconViewTooltipColumnPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint IconViewTooltipColumnPropertyInfo = IconViewK+    type AttrGetType IconViewTooltipColumnPropertyInfo = Int32+    type AttrLabel IconViewTooltipColumnPropertyInfo = "IconView::tooltip-column"+    attrGet _ = getIconViewTooltipColumn+    attrSet _ = setIconViewTooltipColumn+    attrConstruct _ = constructIconViewTooltipColumn++type instance AttributeList IconView = IconViewAttributeList+type IconViewAttributeList = ('[ '("activate-on-single-click", IconViewActivateOnSingleClickPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("cell-area", IconViewCellAreaPropertyInfo), '("child", ContainerChildPropertyInfo), '("column-spacing", IconViewColumnSpacingPropertyInfo), '("columns", IconViewColumnsPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("hadjustment", ScrollableHadjustmentPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hscroll-policy", ScrollableHscrollPolicyPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("item-orientation", IconViewItemOrientationPropertyInfo), '("item-padding", IconViewItemPaddingPropertyInfo), '("item-width", IconViewItemWidthPropertyInfo), '("margin", IconViewMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("markup-column", IconViewMarkupColumnPropertyInfo), '("model", IconViewModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pixbuf-column", IconViewPixbufColumnPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("reorderable", IconViewReorderablePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("row-spacing", IconViewRowSpacingPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selection-mode", IconViewSelectionModePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("spacing", IconViewSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("text-column", IconViewTextColumnPropertyInfo), '("tooltip-column", IconViewTooltipColumnPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("vadjustment", ScrollableVadjustmentPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("vscroll-policy", ScrollableVscrollPolicyPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data IconViewActivateCursorItemSignalInfo+instance SignalInfo IconViewActivateCursorItemSignalInfo where+    type HaskellCallbackType IconViewActivateCursorItemSignalInfo = IconViewActivateCursorItemCallback+    connectSignal _ = connectIconViewActivateCursorItem++data IconViewItemActivatedSignalInfo+instance SignalInfo IconViewItemActivatedSignalInfo where+    type HaskellCallbackType IconViewItemActivatedSignalInfo = IconViewItemActivatedCallback+    connectSignal _ = connectIconViewItemActivated++data IconViewMoveCursorSignalInfo+instance SignalInfo IconViewMoveCursorSignalInfo where+    type HaskellCallbackType IconViewMoveCursorSignalInfo = IconViewMoveCursorCallback+    connectSignal _ = connectIconViewMoveCursor++data IconViewSelectAllSignalInfo+instance SignalInfo IconViewSelectAllSignalInfo where+    type HaskellCallbackType IconViewSelectAllSignalInfo = IconViewSelectAllCallback+    connectSignal _ = connectIconViewSelectAll++data IconViewSelectCursorItemSignalInfo+instance SignalInfo IconViewSelectCursorItemSignalInfo where+    type HaskellCallbackType IconViewSelectCursorItemSignalInfo = IconViewSelectCursorItemCallback+    connectSignal _ = connectIconViewSelectCursorItem++data IconViewSelectionChangedSignalInfo+instance SignalInfo IconViewSelectionChangedSignalInfo where+    type HaskellCallbackType IconViewSelectionChangedSignalInfo = IconViewSelectionChangedCallback+    connectSignal _ = connectIconViewSelectionChanged++data IconViewToggleCursorItemSignalInfo+instance SignalInfo IconViewToggleCursorItemSignalInfo where+    type HaskellCallbackType IconViewToggleCursorItemSignalInfo = IconViewToggleCursorItemCallback+    connectSignal _ = connectIconViewToggleCursorItem++data IconViewUnselectAllSignalInfo+instance SignalInfo IconViewUnselectAllSignalInfo where+    type HaskellCallbackType IconViewUnselectAllSignalInfo = IconViewUnselectAllCallback+    connectSignal _ = connectIconViewUnselectAll++type instance SignalList IconView = IconViewSignalList+type IconViewSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-cursor-item", IconViewActivateCursorItemSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("item-activated", IconViewItemActivatedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", IconViewMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select-all", IconViewSelectAllSignalInfo), '("select-cursor-item", IconViewSelectCursorItemSignalInfo), '("selection-changed", IconViewSelectionChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-cursor-item", IconViewToggleCursorItemSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("unselect-all", IconViewUnselectAllSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method IconView::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "IconView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_new" gtk_icon_view_new :: +    IO (Ptr IconView)+++iconViewNew ::+    (MonadIO m) =>+    m IconView+iconViewNew  = liftIO $ do+    result <- gtk_icon_view_new+    checkUnexpectedReturnNULL "gtk_icon_view_new" result+    result' <- (newObject IconView) result+    return result'++-- method IconView::new_with_area+-- method type : Constructor+-- Args : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "area", argType = TInterface "Gtk" "CellArea", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_new_with_area" gtk_icon_view_new_with_area :: +    Ptr CellArea ->                         -- area : TInterface "Gtk" "CellArea"+    IO (Ptr IconView)+++iconViewNewWithArea ::+    (MonadIO m, CellAreaK a) =>+    a ->                                    -- area+    m IconView+iconViewNewWithArea area = liftIO $ do+    let area' = unsafeManagedPtrCastPtr area+    result <- gtk_icon_view_new_with_area area'+    checkUnexpectedReturnNULL "gtk_icon_view_new_with_area" result+    result' <- (newObject IconView) result+    touchManagedPtr area+    return result'++-- method IconView::new_with_model+-- method type : Constructor+-- Args : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "IconView"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_new_with_model" gtk_icon_view_new_with_model :: +    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO (Ptr IconView)+++iconViewNewWithModel ::+    (MonadIO m, TreeModelK a) =>+    a ->                                    -- model+    m IconView+iconViewNewWithModel model = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_icon_view_new_with_model model'+    checkUnexpectedReturnNULL "gtk_icon_view_new_with_model" result+    result' <- (newObject IconView) result+    touchManagedPtr model+    return result'++-- method IconView::convert_widget_to_bin_window_coords+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wy", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bx", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "by", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wy", 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 "gtk_icon_view_convert_widget_to_bin_window_coords" gtk_icon_view_convert_widget_to_bin_window_coords :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- wx : TBasicType TInt32+    Int32 ->                                -- wy : TBasicType TInt32+    Ptr Int32 ->                            -- bx : TBasicType TInt32+    Ptr Int32 ->                            -- by : TBasicType TInt32+    IO ()+++iconViewConvertWidgetToBinWindowCoords ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- wx+    Int32 ->                                -- wy+    m (Int32,Int32)+iconViewConvertWidgetToBinWindowCoords _obj wx wy = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    bx <- allocMem :: IO (Ptr Int32)+    by <- allocMem :: IO (Ptr Int32)+    gtk_icon_view_convert_widget_to_bin_window_coords _obj' wx wy bx by+    bx' <- peek bx+    by' <- peek by+    touchManagedPtr _obj+    freeMem bx+    freeMem by+    return (bx', by')++-- method IconView::create_drag_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_create_drag_icon" gtk_icon_view_create_drag_icon :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO (Ptr Cairo.Surface)+++iconViewCreateDragIcon ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Cairo.Surface+iconViewCreateDragIcon _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_icon_view_create_drag_icon _obj' path'+    checkUnexpectedReturnNULL "gtk_icon_view_create_drag_icon" result+    result' <- (wrapBoxed Cairo.Surface) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++-- method IconView::enable_model_drag_dest+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_enable_model_drag_dest" gtk_icon_view_enable_model_drag_dest :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TargetEntry ->                      -- targets : TCArray False (-1) 2 (TInterface "Gtk" "TargetEntry")+    Int32 ->                                -- n_targets : TBasicType TInt32+    CUInt ->                                -- actions : TInterface "Gdk" "DragAction"+    IO ()+++iconViewEnableModelDragDest ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    [TargetEntry] ->                        -- targets+    [Gdk.DragAction] ->                     -- actions+    m ()+iconViewEnableModelDragDest _obj targets actions = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let _obj' = unsafeManagedPtrCastPtr _obj+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packBlockArray 16 targets'+    let actions' = gflagsToWord actions+    gtk_icon_view_enable_model_drag_dest _obj' targets'' n_targets actions'+    touchManagedPtr _obj+    mapM_ touchManagedPtr targets+    freeMem targets''+    return ()++-- method IconView::enable_model_drag_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_button_mask", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_targets", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_button_mask", argType = TInterface "Gdk" "ModifierType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "targets", argType = TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "actions", argType = TInterface "Gdk" "DragAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_enable_model_drag_source" gtk_icon_view_enable_model_drag_source :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    CUInt ->                                -- start_button_mask : TInterface "Gdk" "ModifierType"+    Ptr TargetEntry ->                      -- targets : TCArray False (-1) 3 (TInterface "Gtk" "TargetEntry")+    Int32 ->                                -- n_targets : TBasicType TInt32+    CUInt ->                                -- actions : TInterface "Gdk" "DragAction"+    IO ()+++iconViewEnableModelDragSource ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    [Gdk.ModifierType] ->                   -- start_button_mask+    [TargetEntry] ->                        -- targets+    [Gdk.DragAction] ->                     -- actions+    m ()+iconViewEnableModelDragSource _obj start_button_mask targets actions = liftIO $ do+    let n_targets = fromIntegral $ length targets+    let _obj' = unsafeManagedPtrCastPtr _obj+    let start_button_mask' = gflagsToWord start_button_mask+    let targets' = map unsafeManagedPtrGetPtr targets+    targets'' <- packBlockArray 16 targets'+    let actions' = gflagsToWord actions+    gtk_icon_view_enable_model_drag_source _obj' start_button_mask' targets'' n_targets actions'+    touchManagedPtr _obj+    mapM_ touchManagedPtr targets+    freeMem targets''+    return ()++-- method IconView::get_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_activate_on_single_click" gtk_icon_view_get_activate_on_single_click :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO CInt+++iconViewGetActivateOnSingleClick ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Bool+iconViewGetActivateOnSingleClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_activate_on_single_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_cell_rect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_cell_rect" gtk_icon_view_get_cell_rect :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO CInt+++iconViewGetCellRect ::+    (MonadIO m, IconViewK a, CellRendererK b) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    Maybe (b) ->                            -- cell+    m (Bool,Gdk.Rectangle)+iconViewGetCellRect _obj path cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    maybeCell <- case cell of+        Nothing -> return nullPtr+        Just jCell -> do+            let jCell' = unsafeManagedPtrCastPtr jCell+            return jCell'+    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_icon_view_get_cell_rect _obj' path' maybeCell rect+    let result' = (/= 0) result+    rect' <- (wrapBoxed Gdk.Rectangle) rect+    touchManagedPtr _obj+    touchManagedPtr path+    whenJust cell touchManagedPtr+    return (result', rect')++-- method IconView::get_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_column_spacing" gtk_icon_view_get_column_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetColumnSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetColumnSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_column_spacing _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_columns+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_columns" gtk_icon_view_get_columns :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetColumns ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetColumns _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_columns _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_cursor+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_cursor" gtk_icon_view_get_cursor :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    Ptr (Ptr CellRenderer) ->               -- cell : TInterface "Gtk" "CellRenderer"+    IO CInt+++iconViewGetCursor ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m (Bool,TreePath,CellRenderer)+iconViewGetCursor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    cell <- allocMem :: IO (Ptr (Ptr CellRenderer))+    result <- gtk_icon_view_get_cursor _obj' path cell+    let result' = (/= 0) result+    path' <- peek path+    path'' <- (wrapBoxed TreePath) path'+    cell' <- peek cell+    cell'' <- (newObject CellRenderer) cell'+    touchManagedPtr _obj+    freeMem path+    freeMem cell+    return (result', path'', cell'')++-- method IconView::get_dest_item_at_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "drag_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "drag_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "pos", argType = TInterface "Gtk" "IconViewDropPosition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "drag_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "drag_y", 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 "gtk_icon_view_get_dest_item_at_pos" gtk_icon_view_get_dest_item_at_pos :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- drag_x : TBasicType TInt32+    Int32 ->                                -- drag_y : TBasicType TInt32+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    Ptr CUInt ->                            -- pos : TInterface "Gtk" "IconViewDropPosition"+    IO CInt+++iconViewGetDestItemAtPos ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- drag_x+    Int32 ->                                -- drag_y+    m (Bool,TreePath,IconViewDropPosition)+iconViewGetDestItemAtPos _obj drag_x drag_y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    pos <- allocMem :: IO (Ptr CUInt)+    result <- gtk_icon_view_get_dest_item_at_pos _obj' drag_x drag_y path pos+    let result' = (/= 0) result+    path' <- peek path+    path'' <- (wrapBoxed TreePath) path'+    pos' <- peek pos+    let pos'' = (toEnum . fromIntegral) pos'+    touchManagedPtr _obj+    freeMem path+    freeMem pos+    return (result', path'', pos'')++-- method IconView::get_drag_dest_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "pos", argType = TInterface "Gtk" "IconViewDropPosition", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_drag_dest_item" gtk_icon_view_get_drag_dest_item :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    Ptr CUInt ->                            -- pos : TInterface "Gtk" "IconViewDropPosition"+    IO ()+++iconViewGetDragDestItem ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m (TreePath,IconViewDropPosition)+iconViewGetDragDestItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    pos <- allocMem :: IO (Ptr CUInt)+    gtk_icon_view_get_drag_dest_item _obj' path pos+    path' <- peek path+    path'' <- (wrapBoxed TreePath) path'+    pos' <- peek pos+    let pos'' = (toEnum . fromIntegral) pos'+    touchManagedPtr _obj+    freeMem path+    freeMem pos+    return (path'', pos'')++-- method IconView::get_item_at_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_icon_view_get_item_at_pos" gtk_icon_view_get_item_at_pos :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    Ptr (Ptr CellRenderer) ->               -- cell : TInterface "Gtk" "CellRenderer"+    IO CInt+++iconViewGetItemAtPos ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- x+    Int32 ->                                -- y+    m (Bool,TreePath,CellRenderer)+iconViewGetItemAtPos _obj x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    cell <- allocMem :: IO (Ptr (Ptr CellRenderer))+    result <- gtk_icon_view_get_item_at_pos _obj' x y path cell+    let result' = (/= 0) result+    path' <- peek path+    path'' <- (wrapBoxed TreePath) path'+    cell' <- peek cell+    cell'' <- (wrapObject CellRenderer) cell'+    touchManagedPtr _obj+    freeMem path+    freeMem cell+    return (result', path'', cell'')++-- method IconView::get_item_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_item_column" gtk_icon_view_get_item_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO Int32+++iconViewGetItemColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Int32+iconViewGetItemColumn _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_icon_view_get_item_column _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return result++-- method IconView::get_item_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Orientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_item_orientation" gtk_icon_view_get_item_orientation :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO CUInt+++iconViewGetItemOrientation ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Orientation+iconViewGetItemOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_item_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_item_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_item_padding" gtk_icon_view_get_item_padding :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetItemPadding ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetItemPadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_item_padding _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_item_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_item_row" gtk_icon_view_get_item_row :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO Int32+++iconViewGetItemRow ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Int32+iconViewGetItemRow _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_icon_view_get_item_row _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return result++-- method IconView::get_item_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_item_width" gtk_icon_view_get_item_width :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetItemWidth ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetItemWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_item_width _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_margin" gtk_icon_view_get_margin :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetMargin ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetMargin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_margin _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_markup_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_markup_column" gtk_icon_view_get_markup_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetMarkupColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetMarkupColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_markup_column _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreeModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_model" gtk_icon_view_get_model :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO (Ptr TreeModel)+++iconViewGetModel ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m TreeModel+iconViewGetModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_model _obj'+    checkUnexpectedReturnNULL "gtk_icon_view_get_model" result+    result' <- (newObject TreeModel) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_path_at_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "TreePath"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_path_at_pos" gtk_icon_view_get_path_at_pos :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO (Ptr TreePath)+++iconViewGetPathAtPos ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- x+    Int32 ->                                -- y+    m TreePath+iconViewGetPathAtPos _obj x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_path_at_pos _obj' x y+    checkUnexpectedReturnNULL "gtk_icon_view_get_path_at_pos" result+    result' <- (wrapBoxed TreePath) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_pixbuf_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_pixbuf_column" gtk_icon_view_get_pixbuf_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetPixbufColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetPixbufColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_pixbuf_column _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_reorderable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_reorderable" gtk_icon_view_get_reorderable :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO CInt+++iconViewGetReorderable ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Bool+iconViewGetReorderable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_reorderable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_row_spacing" gtk_icon_view_get_row_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetRowSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetRowSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_row_spacing _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_selected_items+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "TreePath")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_selected_items" gtk_icon_view_get_selected_items :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO (Ptr (GList (Ptr TreePath)))+++iconViewGetSelectedItems ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m [TreePath]+iconViewGetSelectedItems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_selected_items _obj'+    checkUnexpectedReturnNULL "gtk_icon_view_get_selected_items" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed TreePath) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method IconView::get_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SelectionMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_selection_mode" gtk_icon_view_get_selection_mode :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO CUInt+++iconViewGetSelectionMode ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m SelectionMode+iconViewGetSelectionMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_selection_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method IconView::get_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_spacing" gtk_icon_view_get_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetSpacing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_spacing _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_text_column" gtk_icon_view_get_text_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetTextColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetTextColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_text_column _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_tooltip_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_tooltip_column" gtk_icon_view_get_tooltip_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO Int32+++iconViewGetTooltipColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m Int32+iconViewGetTooltipColumn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_icon_view_get_tooltip_column _obj'+    touchManagedPtr _obj+    return result++-- method IconView::get_tooltip_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "keyboard_tip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "keyboard_tip", 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 "gtk_icon_view_get_tooltip_context" gtk_icon_view_get_tooltip_context :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr Int32 ->                            -- x : TBasicType TInt32+    Ptr Int32 ->                            -- y : TBasicType TInt32+    CInt ->                                 -- keyboard_tip : TBasicType TBoolean+    Ptr (Ptr TreeModel) ->                  -- model : TInterface "Gtk" "TreeModel"+    Ptr (Ptr TreePath) ->                   -- path : TInterface "Gtk" "TreePath"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++iconViewGetTooltipContext ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- x+    Int32 ->                                -- y+    Bool ->                                 -- keyboard_tip+    m (Bool,Int32,Int32,TreeModel,TreePath,TreeIter)+iconViewGetTooltipContext _obj x y keyboard_tip = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    x' <- allocMem :: IO (Ptr Int32)+    poke x' x+    y' <- allocMem :: IO (Ptr Int32)+    poke y' y+    let keyboard_tip' = (fromIntegral . fromEnum) keyboard_tip+    model <- allocMem :: IO (Ptr (Ptr TreeModel))+    path <- allocMem :: IO (Ptr (Ptr TreePath))+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    result <- gtk_icon_view_get_tooltip_context _obj' x' y' keyboard_tip' model path iter+    let result' = (/= 0) result+    x'' <- peek x'+    y'' <- peek y'+    model' <- peek model+    model'' <- (newObject TreeModel) model'+    path' <- peek path+    path'' <- (wrapBoxed TreePath) path'+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    freeMem x'+    freeMem y'+    freeMem model+    freeMem path+    return (result', x'', y'', model'', path'', iter')++-- method IconView::get_visible_range+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "end_path", argType = TInterface "Gtk" "TreePath", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_get_visible_range" gtk_icon_view_get_visible_range :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr (Ptr TreePath) ->                   -- start_path : TInterface "Gtk" "TreePath"+    Ptr (Ptr TreePath) ->                   -- end_path : TInterface "Gtk" "TreePath"+    IO CInt+++iconViewGetVisibleRange ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m (Bool,TreePath,TreePath)+iconViewGetVisibleRange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    start_path <- allocMem :: IO (Ptr (Ptr TreePath))+    end_path <- allocMem :: IO (Ptr (Ptr TreePath))+    result <- gtk_icon_view_get_visible_range _obj' start_path end_path+    let result' = (/= 0) result+    start_path' <- peek start_path+    start_path'' <- (wrapBoxed TreePath) start_path'+    end_path' <- peek end_path+    end_path'' <- (wrapBoxed TreePath) end_path'+    touchManagedPtr _obj+    freeMem start_path+    freeMem end_path+    return (result', start_path'', end_path'')++-- method IconView::item_activated+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_item_activated" gtk_icon_view_item_activated :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++iconViewItemActivated ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m ()+iconViewItemActivated _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    gtk_icon_view_item_activated _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return ()++-- method IconView::path_is_selected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_path_is_selected" gtk_icon_view_path_is_selected :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO CInt+++iconViewPathIsSelected ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m Bool+iconViewPathIsSelected _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    result <- gtk_icon_view_path_is_selected _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr path+    return result'++-- method IconView::scroll_to_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "col_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_align", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "col_align", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_scroll_to_path" gtk_icon_view_scroll_to_path :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    CInt ->                                 -- use_align : TBasicType TBoolean+    CFloat ->                               -- row_align : TBasicType TFloat+    CFloat ->                               -- col_align : TBasicType TFloat+    IO ()+++iconViewScrollToPath ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    Bool ->                                 -- use_align+    Float ->                                -- row_align+    Float ->                                -- col_align+    m ()+iconViewScrollToPath _obj path use_align row_align col_align = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    let use_align' = (fromIntegral . fromEnum) use_align+    let row_align' = realToFrac row_align+    let col_align' = realToFrac col_align+    gtk_icon_view_scroll_to_path _obj' path' use_align' row_align' col_align'+    touchManagedPtr _obj+    touchManagedPtr path+    return ()++-- method IconView::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_select_all" gtk_icon_view_select_all :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO ()+++iconViewSelectAll ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m ()+iconViewSelectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_select_all _obj'+    touchManagedPtr _obj+    return ()++-- method IconView::select_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_select_path" gtk_icon_view_select_path :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++iconViewSelectPath ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m ()+iconViewSelectPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    gtk_icon_view_select_path _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return ()++-- method IconView::selected_foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "IconViewForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, 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 "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "IconViewForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_selected_foreach" gtk_icon_view_selected_foreach :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    FunPtr IconViewForeachFuncC ->          -- func : TInterface "Gtk" "IconViewForeachFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++iconViewSelectedForeach ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    IconViewForeachFunc ->                  -- func+    m ()+iconViewSelectedForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkIconViewForeachFunc (iconViewForeachFuncWrapper Nothing func)+    let data_ = nullPtr+    gtk_icon_view_selected_foreach _obj' func' data_+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method IconView::set_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", 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 "gtk_icon_view_set_activate_on_single_click" gtk_icon_view_set_activate_on_single_click :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    CInt ->                                 -- single : TBasicType TBoolean+    IO ()+++iconViewSetActivateOnSingleClick ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- single+    m ()+iconViewSetActivateOnSingleClick _obj single = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let single' = (fromIntegral . fromEnum) single+    gtk_icon_view_set_activate_on_single_click _obj' single'+    touchManagedPtr _obj+    return ()++-- method IconView::set_column_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column_spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column_spacing", 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 "gtk_icon_view_set_column_spacing" gtk_icon_view_set_column_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- column_spacing : TBasicType TInt32+    IO ()+++iconViewSetColumnSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column_spacing+    m ()+iconViewSetColumnSpacing _obj column_spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_column_spacing _obj' column_spacing+    touchManagedPtr _obj+    return ()++-- method IconView::set_columns+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", 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 "gtk_icon_view_set_columns" gtk_icon_view_set_columns :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- columns : TBasicType TInt32+    IO ()+++iconViewSetColumns ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- columns+    m ()+iconViewSetColumns _obj columns = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_columns _obj' columns+    touchManagedPtr _obj+    return ()++-- method IconView::set_cursor+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_editing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_editing", 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 "gtk_icon_view_set_cursor" gtk_icon_view_set_cursor :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    CInt ->                                 -- start_editing : TBasicType TBoolean+    IO ()+++iconViewSetCursor ::+    (MonadIO m, IconViewK a, CellRendererK b) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    Maybe (b) ->                            -- cell+    Bool ->                                 -- start_editing+    m ()+iconViewSetCursor _obj path cell start_editing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    maybeCell <- case cell of+        Nothing -> return nullPtr+        Just jCell -> do+            let jCell' = unsafeManagedPtrCastPtr jCell+            return jCell'+    let start_editing' = (fromIntegral . fromEnum) start_editing+    gtk_icon_view_set_cursor _obj' path' maybeCell start_editing'+    touchManagedPtr _obj+    touchManagedPtr path+    whenJust cell touchManagedPtr+    return ()++-- method IconView::set_drag_dest_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "IconViewDropPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "IconViewDropPosition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_drag_dest_item" gtk_icon_view_set_drag_dest_item :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    CUInt ->                                -- pos : TInterface "Gtk" "IconViewDropPosition"+    IO ()+++iconViewSetDragDestItem ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Maybe (TreePath) ->                     -- path+    IconViewDropPosition ->                 -- pos+    m ()+iconViewSetDragDestItem _obj path pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePath <- case path of+        Nothing -> return nullPtr+        Just jPath -> do+            let jPath' = unsafeManagedPtrGetPtr jPath+            return jPath'+    let pos' = (fromIntegral . fromEnum) pos+    gtk_icon_view_set_drag_dest_item _obj' maybePath pos'+    touchManagedPtr _obj+    whenJust path touchManagedPtr+    return ()++-- method IconView::set_item_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_item_orientation" gtk_icon_view_set_item_orientation :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO ()+++iconViewSetItemOrientation ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Orientation ->                          -- orientation+    m ()+iconViewSetItemOrientation _obj orientation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_icon_view_set_item_orientation _obj' orientation'+    touchManagedPtr _obj+    return ()++-- method IconView::set_item_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_padding", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_padding", 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 "gtk_icon_view_set_item_padding" gtk_icon_view_set_item_padding :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- item_padding : TBasicType TInt32+    IO ()+++iconViewSetItemPadding ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_padding+    m ()+iconViewSetItemPadding _obj item_padding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_item_padding _obj' item_padding+    touchManagedPtr _obj+    return ()++-- method IconView::set_item_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_width", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "item_width", 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 "gtk_icon_view_set_item_width" gtk_icon_view_set_item_width :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- item_width : TBasicType TInt32+    IO ()+++iconViewSetItemWidth ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- item_width+    m ()+iconViewSetItemWidth _obj item_width = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_item_width _obj' item_width+    touchManagedPtr _obj+    return ()++-- method IconView::set_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", 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 "gtk_icon_view_set_margin" gtk_icon_view_set_margin :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- margin : TBasicType TInt32+    IO ()+++iconViewSetMargin ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- margin+    m ()+iconViewSetMargin _obj margin = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_margin _obj' margin+    touchManagedPtr _obj+    return ()++-- method IconView::set_markup_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_icon_view_set_markup_column" gtk_icon_view_set_markup_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++iconViewSetMarkupColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column+    m ()+iconViewSetMarkupColumn _obj column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_markup_column _obj' column+    touchManagedPtr _obj+    return ()++-- method IconView::set_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gtk" "TreeModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_model" gtk_icon_view_set_model :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreeModel ->                        -- model : TInterface "Gtk" "TreeModel"+    IO ()+++iconViewSetModel ::+    (MonadIO m, IconViewK a, TreeModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    m ()+iconViewSetModel _obj model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    gtk_icon_view_set_model _obj' maybeModel+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    return ()++-- method IconView::set_pixbuf_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_icon_view_set_pixbuf_column" gtk_icon_view_set_pixbuf_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++iconViewSetPixbufColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column+    m ()+iconViewSetPixbufColumn _obj column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_pixbuf_column _obj' column+    touchManagedPtr _obj+    return ()++-- method IconView::set_reorderable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reorderable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reorderable", 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 "gtk_icon_view_set_reorderable" gtk_icon_view_set_reorderable :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    CInt ->                                 -- reorderable : TBasicType TBoolean+    IO ()+++iconViewSetReorderable ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- reorderable+    m ()+iconViewSetReorderable _obj reorderable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let reorderable' = (fromIntegral . fromEnum) reorderable+    gtk_icon_view_set_reorderable _obj' reorderable'+    touchManagedPtr _obj+    return ()++-- method IconView::set_row_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row_spacing", 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 "gtk_icon_view_set_row_spacing" gtk_icon_view_set_row_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- row_spacing : TBasicType TInt32+    IO ()+++iconViewSetRowSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- row_spacing+    m ()+iconViewSetRowSpacing _obj row_spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_row_spacing _obj' row_spacing+    touchManagedPtr _obj+    return ()++-- method IconView::set_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_selection_mode" gtk_icon_view_set_selection_mode :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    CUInt ->                                -- mode : TInterface "Gtk" "SelectionMode"+    IO ()+++iconViewSetSelectionMode ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    SelectionMode ->                        -- mode+    m ()+iconViewSetSelectionMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_icon_view_set_selection_mode _obj' mode'+    touchManagedPtr _obj+    return ()++-- method IconView::set_spacing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "spacing", 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 "gtk_icon_view_set_spacing" gtk_icon_view_set_spacing :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- spacing : TBasicType TInt32+    IO ()+++iconViewSetSpacing ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- spacing+    m ()+iconViewSetSpacing _obj spacing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_spacing _obj' spacing+    touchManagedPtr _obj+    return ()++-- method IconView::set_text_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_icon_view_set_text_column" gtk_icon_view_set_text_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++iconViewSetTextColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column+    m ()+iconViewSetTextColumn _obj column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_text_column _obj' column+    touchManagedPtr _obj+    return ()++-- method IconView::set_tooltip_cell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TInterface "Gtk" "Tooltip", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TInterface "Gtk" "Tooltip", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cell", argType = TInterface "Gtk" "CellRenderer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_tooltip_cell" gtk_icon_view_set_tooltip_cell :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr Tooltip ->                          -- tooltip : TInterface "Gtk" "Tooltip"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    Ptr CellRenderer ->                     -- cell : TInterface "Gtk" "CellRenderer"+    IO ()+++iconViewSetTooltipCell ::+    (MonadIO m, IconViewK a, TooltipK b, CellRendererK c) =>+    a ->                                    -- _obj+    b ->                                    -- tooltip+    TreePath ->                             -- path+    Maybe (c) ->                            -- cell+    m ()+iconViewSetTooltipCell _obj tooltip path cell = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let tooltip' = unsafeManagedPtrCastPtr tooltip+    let path' = unsafeManagedPtrGetPtr path+    maybeCell <- case cell of+        Nothing -> return nullPtr+        Just jCell -> do+            let jCell' = unsafeManagedPtrCastPtr jCell+            return jCell'+    gtk_icon_view_set_tooltip_cell _obj' tooltip' path' maybeCell+    touchManagedPtr _obj+    touchManagedPtr tooltip+    touchManagedPtr path+    whenJust cell touchManagedPtr+    return ()++-- method IconView::set_tooltip_column+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", 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 "gtk_icon_view_set_tooltip_column" gtk_icon_view_set_tooltip_column :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Int32 ->                                -- column : TBasicType TInt32+    IO ()+++iconViewSetTooltipColumn ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- column+    m ()+iconViewSetTooltipColumn _obj column = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_set_tooltip_column _obj' column+    touchManagedPtr _obj+    return ()++-- method IconView::set_tooltip_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TInterface "Gtk" "Tooltip", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TInterface "Gtk" "Tooltip", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_set_tooltip_item" gtk_icon_view_set_tooltip_item :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr Tooltip ->                          -- tooltip : TInterface "Gtk" "Tooltip"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++iconViewSetTooltipItem ::+    (MonadIO m, IconViewK a, TooltipK b) =>+    a ->                                    -- _obj+    b ->                                    -- tooltip+    TreePath ->                             -- path+    m ()+iconViewSetTooltipItem _obj tooltip path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let tooltip' = unsafeManagedPtrCastPtr tooltip+    let path' = unsafeManagedPtrGetPtr path+    gtk_icon_view_set_tooltip_item _obj' tooltip' path'+    touchManagedPtr _obj+    touchManagedPtr tooltip+    touchManagedPtr path+    return ()++-- method IconView::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_unselect_all" gtk_icon_view_unselect_all :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO ()+++iconViewUnselectAll ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m ()+iconViewUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method IconView::unselect_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TInterface "Gtk" "TreePath", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_unselect_path" gtk_icon_view_unselect_path :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    Ptr TreePath ->                         -- path : TInterface "Gtk" "TreePath"+    IO ()+++iconViewUnselectPath ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    TreePath ->                             -- path+    m ()+iconViewUnselectPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let path' = unsafeManagedPtrGetPtr path+    gtk_icon_view_unselect_path _obj' path'+    touchManagedPtr _obj+    touchManagedPtr path+    return ()++-- method IconView::unset_model_drag_dest+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_unset_model_drag_dest" gtk_icon_view_unset_model_drag_dest :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO ()+++iconViewUnsetModelDragDest ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m ()+iconViewUnsetModelDragDest _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_unset_model_drag_dest _obj'+    touchManagedPtr _obj+    return ()++-- method IconView::unset_model_drag_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "IconView", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_icon_view_unset_model_drag_source" gtk_icon_view_unset_model_drag_source :: +    Ptr IconView ->                         -- _obj : TInterface "Gtk" "IconView"+    IO ()+++iconViewUnsetModelDragSource ::+    (MonadIO m, IconViewK a) =>+    a ->                                    -- _obj+    m ()+iconViewUnsetModelDragSource _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_icon_view_unset_model_drag_source _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/IconView.hs-boot view
@@ -0,0 +1,38 @@+module GI.Gtk.Objects.IconView where++import Prelude ()+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 IconView = IconView (ForeignPtr IconView)+instance GObject IconView where+class GObject o => IconViewK o+instance (GObject o, IsDescendantOf IconView o) => IconViewK o+data IconViewActivateOnSingleClickPropertyInfo+data IconViewCellAreaPropertyInfo+data IconViewColumnSpacingPropertyInfo+data IconViewColumnsPropertyInfo+data IconViewItemOrientationPropertyInfo+data IconViewItemPaddingPropertyInfo+data IconViewItemWidthPropertyInfo+data IconViewMarginPropertyInfo+data IconViewMarkupColumnPropertyInfo+data IconViewModelPropertyInfo+data IconViewPixbufColumnPropertyInfo+data IconViewReorderablePropertyInfo+data IconViewRowSpacingPropertyInfo+data IconViewSelectionModePropertyInfo+data IconViewSpacingPropertyInfo+data IconViewTextColumnPropertyInfo+data IconViewTooltipColumnPropertyInfo+data IconViewActivateCursorItemSignalInfo+data IconViewItemActivatedSignalInfo+data IconViewMoveCursorSignalInfo+data IconViewSelectAllSignalInfo+data IconViewSelectCursorItemSignalInfo+data IconViewSelectionChangedSignalInfo+data IconViewToggleCursorItemSignalInfo+data IconViewUnselectAllSignalInfo
+ GI/Gtk/Objects/IconViewAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.IconViewAccessible+    ( ++-- * Exported types+    IconViewAccessible(..)                  ,+    IconViewAccessibleK                     ,+    toIconViewAccessible                    ,+    noIconViewAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype IconViewAccessible = IconViewAccessible (ForeignPtr IconViewAccessible)+foreign import ccall "gtk_icon_view_accessible_get_type"+    c_gtk_icon_view_accessible_get_type :: IO GType++type instance ParentTypes IconViewAccessible = IconViewAccessibleParentTypes+type IconViewAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject IconViewAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_icon_view_accessible_get_type+    ++class GObject o => IconViewAccessibleK o+instance (GObject o, IsDescendantOf IconViewAccessible o) => IconViewAccessibleK o++toIconViewAccessible :: IconViewAccessibleK o => o -> IO IconViewAccessible+toIconViewAccessible = unsafeCastTo IconViewAccessible++noIconViewAccessible :: Maybe IconViewAccessible+noIconViewAccessible = Nothing++type instance AttributeList IconViewAccessible = IconViewAccessibleAttributeList+type IconViewAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList IconViewAccessible = IconViewAccessibleSignalList+type IconViewAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/IconViewAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.IconViewAccessible where++import Prelude ()+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 IconViewAccessible = IconViewAccessible (ForeignPtr IconViewAccessible)+instance GObject IconViewAccessible where+class GObject o => IconViewAccessibleK o+instance (GObject o, IsDescendantOf IconViewAccessible o) => IconViewAccessibleK o
+ GI/Gtk/Objects/Image.hs view
@@ -0,0 +1,1406 @@++{- |+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.Gtk.Objects.Image+    ( ++-- * Exported types+    Image(..)                               ,+    ImageK                                  ,+    toImage                                 ,+    noImage                                 ,+++ -- * Methods+-- ** imageClear+    imageClear                              ,+++-- ** imageGetAnimation+    imageGetAnimation                       ,+++-- ** imageGetGicon+    imageGetGicon                           ,+++-- ** imageGetIconName+    imageGetIconName                        ,+++-- ** imageGetIconSet+    imageGetIconSet                         ,+++-- ** imageGetPixbuf+    imageGetPixbuf                          ,+++-- ** imageGetPixelSize+    imageGetPixelSize                       ,+++-- ** imageGetStock+    imageGetStock                           ,+++-- ** imageGetStorageType+    imageGetStorageType                     ,+++-- ** imageNew+    imageNew                                ,+++-- ** imageNewFromAnimation+    imageNewFromAnimation                   ,+++-- ** imageNewFromFile+    imageNewFromFile                        ,+++-- ** imageNewFromGicon+    imageNewFromGicon                       ,+++-- ** imageNewFromIconName+    imageNewFromIconName                    ,+++-- ** imageNewFromIconSet+    imageNewFromIconSet                     ,+++-- ** imageNewFromPixbuf+    imageNewFromPixbuf                      ,+++-- ** imageNewFromResource+    imageNewFromResource                    ,+++-- ** imageNewFromStock+    imageNewFromStock                       ,+++-- ** imageNewFromSurface+    imageNewFromSurface                     ,+++-- ** imageSetFromAnimation+    imageSetFromAnimation                   ,+++-- ** imageSetFromFile+    imageSetFromFile                        ,+++-- ** imageSetFromGicon+    imageSetFromGicon                       ,+++-- ** imageSetFromIconName+    imageSetFromIconName                    ,+++-- ** imageSetFromIconSet+    imageSetFromIconSet                     ,+++-- ** imageSetFromPixbuf+    imageSetFromPixbuf                      ,+++-- ** imageSetFromResource+    imageSetFromResource                    ,+++-- ** imageSetFromStock+    imageSetFromStock                       ,+++-- ** imageSetFromSurface+    imageSetFromSurface                     ,+++-- ** imageSetPixelSize+    imageSetPixelSize                       ,+++++ -- * Properties+-- ** File+    ImageFilePropertyInfo                   ,+    constructImageFile                      ,+    getImageFile                            ,+    setImageFile                            ,+++-- ** Gicon+    ImageGiconPropertyInfo                  ,+    constructImageGicon                     ,+    getImageGicon                           ,+    setImageGicon                           ,+++-- ** IconName+    ImageIconNamePropertyInfo               ,+    constructImageIconName                  ,+    getImageIconName                        ,+    setImageIconName                        ,+++-- ** IconSet+    ImageIconSetPropertyInfo                ,+    constructImageIconSet                   ,+    getImageIconSet                         ,+    setImageIconSet                         ,+++-- ** IconSize+    ImageIconSizePropertyInfo               ,+    constructImageIconSize                  ,+    getImageIconSize                        ,+    setImageIconSize                        ,+++-- ** Pixbuf+    ImagePixbufPropertyInfo                 ,+    constructImagePixbuf                    ,+    getImagePixbuf                          ,+    setImagePixbuf                          ,+++-- ** PixbufAnimation+    ImagePixbufAnimationPropertyInfo        ,+    constructImagePixbufAnimation           ,+    getImagePixbufAnimation                 ,+    setImagePixbufAnimation                 ,+++-- ** PixelSize+    ImagePixelSizePropertyInfo              ,+    constructImagePixelSize                 ,+    getImagePixelSize                       ,+    setImagePixelSize                       ,+++-- ** Resource+    ImageResourcePropertyInfo               ,+    constructImageResource                  ,+    getImageResource                        ,+    setImageResource                        ,+++-- ** Stock+    ImageStockPropertyInfo                  ,+    constructImageStock                     ,+    getImageStock                           ,+    setImageStock                           ,+++-- ** StorageType+    ImageStorageTypePropertyInfo            ,+    getImageStorageType                     ,+++-- ** Surface+    ImageSurfacePropertyInfo                ,+    constructImageSurface                   ,+    getImageSurface                         ,+    setImageSurface                         ,+++-- ** UseFallback+    ImageUseFallbackPropertyInfo            ,+    constructImageUseFallback               ,+    getImageUseFallback                     ,+    setImageUseFallback                     ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Gio as Gio+import qualified GI.Cairo as Cairo++newtype Image = Image (ForeignPtr Image)+foreign import ccall "gtk_image_get_type"+    c_gtk_image_get_type :: IO GType++type instance ParentTypes Image = ImageParentTypes+type ImageParentTypes = '[Misc, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Image where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_image_get_type+    ++class GObject o => ImageK o+instance (GObject o, IsDescendantOf Image o) => ImageK o++toImage :: ImageK o => o -> IO Image+toImage = unsafeCastTo Image++noImage :: Maybe Image+noImage = Nothing++-- VVV Prop "file"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getImageFile :: (MonadIO m, ImageK o) => o -> m T.Text+getImageFile obj = liftIO $ getObjectPropertyString obj "file"++setImageFile :: (MonadIO m, ImageK o) => o -> T.Text -> m ()+setImageFile obj val = liftIO $ setObjectPropertyString obj "file" val++constructImageFile :: T.Text -> IO ([Char], GValue)+constructImageFile val = constructObjectPropertyString "file" val++data ImageFilePropertyInfo+instance AttrInfo ImageFilePropertyInfo where+    type AttrAllowedOps ImageFilePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageFilePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ImageFilePropertyInfo = ImageK+    type AttrGetType ImageFilePropertyInfo = T.Text+    type AttrLabel ImageFilePropertyInfo = "Image::file"+    attrGet _ = getImageFile+    attrSet _ = setImageFile+    attrConstruct _ = constructImageFile++-- VVV Prop "gicon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getImageGicon :: (MonadIO m, ImageK o) => o -> m Gio.Icon+getImageGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Gio.Icon++setImageGicon :: (MonadIO m, ImageK o, Gio.IconK a) => o -> a -> m ()+setImageGicon obj val = liftIO $ setObjectPropertyObject obj "gicon" val++constructImageGicon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructImageGicon val = constructObjectPropertyObject "gicon" val++data ImageGiconPropertyInfo+instance AttrInfo ImageGiconPropertyInfo where+    type AttrAllowedOps ImageGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageGiconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint ImageGiconPropertyInfo = ImageK+    type AttrGetType ImageGiconPropertyInfo = Gio.Icon+    type AttrLabel ImageGiconPropertyInfo = "Image::gicon"+    attrGet _ = getImageGicon+    attrSet _ = setImageGicon+    attrConstruct _ = constructImageGicon++-- VVV Prop "icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getImageIconName :: (MonadIO m, ImageK o) => o -> m T.Text+getImageIconName obj = liftIO $ getObjectPropertyString obj "icon-name"++setImageIconName :: (MonadIO m, ImageK o) => o -> T.Text -> m ()+setImageIconName obj val = liftIO $ setObjectPropertyString obj "icon-name" val++constructImageIconName :: T.Text -> IO ([Char], GValue)+constructImageIconName val = constructObjectPropertyString "icon-name" val++data ImageIconNamePropertyInfo+instance AttrInfo ImageIconNamePropertyInfo where+    type AttrAllowedOps ImageIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ImageIconNamePropertyInfo = ImageK+    type AttrGetType ImageIconNamePropertyInfo = T.Text+    type AttrLabel ImageIconNamePropertyInfo = "Image::icon-name"+    attrGet _ = getImageIconName+    attrSet _ = setImageIconName+    attrConstruct _ = constructImageIconName++-- VVV Prop "icon-set"+   -- Type: TInterface "Gtk" "IconSet"+   -- Flags: [PropertyReadable,PropertyWritable]++getImageIconSet :: (MonadIO m, ImageK o) => o -> m IconSet+getImageIconSet obj = liftIO $ getObjectPropertyBoxed obj "icon-set" IconSet++setImageIconSet :: (MonadIO m, ImageK o) => o -> IconSet -> m ()+setImageIconSet obj val = liftIO $ setObjectPropertyBoxed obj "icon-set" val++constructImageIconSet :: IconSet -> IO ([Char], GValue)+constructImageIconSet val = constructObjectPropertyBoxed "icon-set" val++data ImageIconSetPropertyInfo+instance AttrInfo ImageIconSetPropertyInfo where+    type AttrAllowedOps ImageIconSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageIconSetPropertyInfo = (~) IconSet+    type AttrBaseTypeConstraint ImageIconSetPropertyInfo = ImageK+    type AttrGetType ImageIconSetPropertyInfo = IconSet+    type AttrLabel ImageIconSetPropertyInfo = "Image::icon-set"+    attrGet _ = getImageIconSet+    attrSet _ = setImageIconSet+    attrConstruct _ = constructImageIconSet++-- VVV Prop "icon-size"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getImageIconSize :: (MonadIO m, ImageK o) => o -> m Int32+getImageIconSize obj = liftIO $ getObjectPropertyCInt obj "icon-size"++setImageIconSize :: (MonadIO m, ImageK o) => o -> Int32 -> m ()+setImageIconSize obj val = liftIO $ setObjectPropertyCInt obj "icon-size" val++constructImageIconSize :: Int32 -> IO ([Char], GValue)+constructImageIconSize val = constructObjectPropertyCInt "icon-size" val++data ImageIconSizePropertyInfo+instance AttrInfo ImageIconSizePropertyInfo where+    type AttrAllowedOps ImageIconSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageIconSizePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ImageIconSizePropertyInfo = ImageK+    type AttrGetType ImageIconSizePropertyInfo = Int32+    type AttrLabel ImageIconSizePropertyInfo = "Image::icon-size"+    attrGet _ = getImageIconSize+    attrSet _ = setImageIconSize+    attrConstruct _ = constructImageIconSize++-- VVV Prop "pixbuf"+   -- Type: TInterface "GdkPixbuf" "Pixbuf"+   -- Flags: [PropertyReadable,PropertyWritable]++getImagePixbuf :: (MonadIO m, ImageK o) => o -> m GdkPixbuf.Pixbuf+getImagePixbuf obj = liftIO $ getObjectPropertyObject obj "pixbuf" GdkPixbuf.Pixbuf++setImagePixbuf :: (MonadIO m, ImageK o, GdkPixbuf.PixbufK a) => o -> a -> m ()+setImagePixbuf obj val = liftIO $ setObjectPropertyObject obj "pixbuf" val++constructImagePixbuf :: (GdkPixbuf.PixbufK a) => a -> IO ([Char], GValue)+constructImagePixbuf val = constructObjectPropertyObject "pixbuf" val++data ImagePixbufPropertyInfo+instance AttrInfo ImagePixbufPropertyInfo where+    type AttrAllowedOps ImagePixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImagePixbufPropertyInfo = GdkPixbuf.PixbufK+    type AttrBaseTypeConstraint ImagePixbufPropertyInfo = ImageK+    type AttrGetType ImagePixbufPropertyInfo = GdkPixbuf.Pixbuf+    type AttrLabel ImagePixbufPropertyInfo = "Image::pixbuf"+    attrGet _ = getImagePixbuf+    attrSet _ = setImagePixbuf+    attrConstruct _ = constructImagePixbuf++-- VVV Prop "pixbuf-animation"+   -- Type: TInterface "GdkPixbuf" "PixbufAnimation"+   -- Flags: [PropertyReadable,PropertyWritable]++getImagePixbufAnimation :: (MonadIO m, ImageK o) => o -> m GdkPixbuf.PixbufAnimation+getImagePixbufAnimation obj = liftIO $ getObjectPropertyObject obj "pixbuf-animation" GdkPixbuf.PixbufAnimation++setImagePixbufAnimation :: (MonadIO m, ImageK o, GdkPixbuf.PixbufAnimationK a) => o -> a -> m ()+setImagePixbufAnimation obj val = liftIO $ setObjectPropertyObject obj "pixbuf-animation" val++constructImagePixbufAnimation :: (GdkPixbuf.PixbufAnimationK a) => a -> IO ([Char], GValue)+constructImagePixbufAnimation val = constructObjectPropertyObject "pixbuf-animation" val++data ImagePixbufAnimationPropertyInfo+instance AttrInfo ImagePixbufAnimationPropertyInfo where+    type AttrAllowedOps ImagePixbufAnimationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImagePixbufAnimationPropertyInfo = GdkPixbuf.PixbufAnimationK+    type AttrBaseTypeConstraint ImagePixbufAnimationPropertyInfo = ImageK+    type AttrGetType ImagePixbufAnimationPropertyInfo = GdkPixbuf.PixbufAnimation+    type AttrLabel ImagePixbufAnimationPropertyInfo = "Image::pixbuf-animation"+    attrGet _ = getImagePixbufAnimation+    attrSet _ = setImagePixbufAnimation+    attrConstruct _ = constructImagePixbufAnimation++-- VVV Prop "pixel-size"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getImagePixelSize :: (MonadIO m, ImageK o) => o -> m Int32+getImagePixelSize obj = liftIO $ getObjectPropertyCInt obj "pixel-size"++setImagePixelSize :: (MonadIO m, ImageK o) => o -> Int32 -> m ()+setImagePixelSize obj val = liftIO $ setObjectPropertyCInt obj "pixel-size" val++constructImagePixelSize :: Int32 -> IO ([Char], GValue)+constructImagePixelSize val = constructObjectPropertyCInt "pixel-size" val++data ImagePixelSizePropertyInfo+instance AttrInfo ImagePixelSizePropertyInfo where+    type AttrAllowedOps ImagePixelSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImagePixelSizePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ImagePixelSizePropertyInfo = ImageK+    type AttrGetType ImagePixelSizePropertyInfo = Int32+    type AttrLabel ImagePixelSizePropertyInfo = "Image::pixel-size"+    attrGet _ = getImagePixelSize+    attrSet _ = setImagePixelSize+    attrConstruct _ = constructImagePixelSize++-- VVV Prop "resource"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getImageResource :: (MonadIO m, ImageK o) => o -> m T.Text+getImageResource obj = liftIO $ getObjectPropertyString obj "resource"++setImageResource :: (MonadIO m, ImageK o) => o -> T.Text -> m ()+setImageResource obj val = liftIO $ setObjectPropertyString obj "resource" val++constructImageResource :: T.Text -> IO ([Char], GValue)+constructImageResource val = constructObjectPropertyString "resource" val++data ImageResourcePropertyInfo+instance AttrInfo ImageResourcePropertyInfo where+    type AttrAllowedOps ImageResourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageResourcePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ImageResourcePropertyInfo = ImageK+    type AttrGetType ImageResourcePropertyInfo = T.Text+    type AttrLabel ImageResourcePropertyInfo = "Image::resource"+    attrGet _ = getImageResource+    attrSet _ = setImageResource+    attrConstruct _ = constructImageResource++-- VVV Prop "stock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getImageStock :: (MonadIO m, ImageK o) => o -> m T.Text+getImageStock obj = liftIO $ getObjectPropertyString obj "stock"++setImageStock :: (MonadIO m, ImageK o) => o -> T.Text -> m ()+setImageStock obj val = liftIO $ setObjectPropertyString obj "stock" val++constructImageStock :: T.Text -> IO ([Char], GValue)+constructImageStock val = constructObjectPropertyString "stock" val++data ImageStockPropertyInfo+instance AttrInfo ImageStockPropertyInfo where+    type AttrAllowedOps ImageStockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageStockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ImageStockPropertyInfo = ImageK+    type AttrGetType ImageStockPropertyInfo = T.Text+    type AttrLabel ImageStockPropertyInfo = "Image::stock"+    attrGet _ = getImageStock+    attrSet _ = setImageStock+    attrConstruct _ = constructImageStock++-- VVV Prop "storage-type"+   -- Type: TInterface "Gtk" "ImageType"+   -- Flags: [PropertyReadable]++getImageStorageType :: (MonadIO m, ImageK o) => o -> m ImageType+getImageStorageType obj = liftIO $ getObjectPropertyEnum obj "storage-type"++data ImageStorageTypePropertyInfo+instance AttrInfo ImageStorageTypePropertyInfo where+    type AttrAllowedOps ImageStorageTypePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint ImageStorageTypePropertyInfo = (~) ()+    type AttrBaseTypeConstraint ImageStorageTypePropertyInfo = ImageK+    type AttrGetType ImageStorageTypePropertyInfo = ImageType+    type AttrLabel ImageStorageTypePropertyInfo = "Image::storage-type"+    attrGet _ = getImageStorageType+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "surface"+   -- Type: TInterface "cairo" "Surface"+   -- Flags: [PropertyReadable,PropertyWritable]++getImageSurface :: (MonadIO m, ImageK o) => o -> m Cairo.Surface+getImageSurface obj = liftIO $ getObjectPropertyBoxed obj "surface" Cairo.Surface++setImageSurface :: (MonadIO m, ImageK o) => o -> Cairo.Surface -> m ()+setImageSurface obj val = liftIO $ setObjectPropertyBoxed obj "surface" val++constructImageSurface :: Cairo.Surface -> IO ([Char], GValue)+constructImageSurface val = constructObjectPropertyBoxed "surface" val++data ImageSurfacePropertyInfo+instance AttrInfo ImageSurfacePropertyInfo where+    type AttrAllowedOps ImageSurfacePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageSurfacePropertyInfo = (~) Cairo.Surface+    type AttrBaseTypeConstraint ImageSurfacePropertyInfo = ImageK+    type AttrGetType ImageSurfacePropertyInfo = Cairo.Surface+    type AttrLabel ImageSurfacePropertyInfo = "Image::surface"+    attrGet _ = getImageSurface+    attrSet _ = setImageSurface+    attrConstruct _ = constructImageSurface++-- VVV Prop "use-fallback"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getImageUseFallback :: (MonadIO m, ImageK o) => o -> m Bool+getImageUseFallback obj = liftIO $ getObjectPropertyBool obj "use-fallback"++setImageUseFallback :: (MonadIO m, ImageK o) => o -> Bool -> m ()+setImageUseFallback obj val = liftIO $ setObjectPropertyBool obj "use-fallback" val++constructImageUseFallback :: Bool -> IO ([Char], GValue)+constructImageUseFallback val = constructObjectPropertyBool "use-fallback" val++data ImageUseFallbackPropertyInfo+instance AttrInfo ImageUseFallbackPropertyInfo where+    type AttrAllowedOps ImageUseFallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageUseFallbackPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ImageUseFallbackPropertyInfo = ImageK+    type AttrGetType ImageUseFallbackPropertyInfo = Bool+    type AttrLabel ImageUseFallbackPropertyInfo = "Image::use-fallback"+    attrGet _ = getImageUseFallback+    attrSet _ = setImageUseFallback+    attrConstruct _ = constructImageUseFallback++type instance AttributeList Image = ImageAttributeList+type ImageAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("file", ImageFilePropertyInfo), '("gicon", ImageGiconPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("icon-name", ImageIconNamePropertyInfo), '("icon-set", ImageIconSetPropertyInfo), '("icon-size", ImageIconSizePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pixbuf", ImagePixbufPropertyInfo), '("pixbuf-animation", ImagePixbufAnimationPropertyInfo), '("pixel-size", ImagePixelSizePropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resource", ImageResourcePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("stock", ImageStockPropertyInfo), '("storage-type", ImageStorageTypePropertyInfo), '("style", WidgetStylePropertyInfo), '("surface", ImageSurfacePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-fallback", ImageUseFallbackPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", MiscXalignPropertyInfo), '("xpad", MiscXpadPropertyInfo), '("yalign", MiscYalignPropertyInfo), '("ypad", MiscYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Image = ImageSignalList+type ImageSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Image::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new" gtk_image_new :: +    IO (Ptr Image)+++imageNew ::+    (MonadIO m) =>+    m Image+imageNew  = liftIO $ do+    result <- gtk_image_new+    checkUnexpectedReturnNULL "gtk_image_new" result+    result' <- (newObject Image) result+    return result'++-- method Image::new_from_animation+-- method type : Constructor+-- Args : [Arg {argName = "animation", argType = TInterface "GdkPixbuf" "PixbufAnimation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "animation", argType = TInterface "GdkPixbuf" "PixbufAnimation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_animation" gtk_image_new_from_animation :: +    Ptr GdkPixbuf.PixbufAnimation ->        -- animation : TInterface "GdkPixbuf" "PixbufAnimation"+    IO (Ptr Image)+++imageNewFromAnimation ::+    (MonadIO m, GdkPixbuf.PixbufAnimationK a) =>+    a ->                                    -- animation+    m Image+imageNewFromAnimation animation = liftIO $ do+    let animation' = unsafeManagedPtrCastPtr animation+    result <- gtk_image_new_from_animation animation'+    checkUnexpectedReturnNULL "gtk_image_new_from_animation" result+    result' <- (newObject Image) result+    touchManagedPtr animation+    return result'++-- method Image::new_from_file+-- method type : Constructor+-- 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 "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_file" gtk_image_new_from_file :: +    CString ->                              -- filename : TBasicType TFileName+    IO (Ptr Image)+++imageNewFromFile ::+    (MonadIO m) =>+    [Char] ->                               -- filename+    m Image+imageNewFromFile filename = liftIO $ do+    filename' <- stringToCString filename+    result <- gtk_image_new_from_file filename'+    checkUnexpectedReturnNULL "gtk_image_new_from_file" result+    result' <- (newObject Image) result+    freeMem filename'+    return result'++-- method Image::new_from_gicon+-- 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 = "size", argType = TBasicType TInt32, 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 = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_gicon" gtk_image_new_from_gicon :: +    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr Image)+++imageNewFromGicon ::+    (MonadIO m, Gio.IconK a) =>+    a ->                                    -- icon+    Int32 ->                                -- size+    m Image+imageNewFromGicon icon size = liftIO $ do+    let icon' = unsafeManagedPtrCastPtr icon+    result <- gtk_image_new_from_gicon icon' size+    checkUnexpectedReturnNULL "gtk_image_new_from_gicon" result+    result' <- (newObject Image) result+    touchManagedPtr icon+    return result'++-- method Image::new_from_icon_name+-- method type : Constructor+-- Args : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_icon_name" gtk_image_new_from_icon_name :: +    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr Image)+++imageNewFromIconName ::+    (MonadIO m) =>+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    m Image+imageNewFromIconName icon_name size = liftIO $ do+    icon_name' <- textToCString icon_name+    result <- gtk_image_new_from_icon_name icon_name' size+    checkUnexpectedReturnNULL "gtk_image_new_from_icon_name" result+    result' <- (newObject Image) result+    freeMem icon_name'+    return result'++-- method Image::new_from_icon_set+-- method type : Constructor+-- Args : [Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", 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}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_icon_set" gtk_image_new_from_icon_set :: +    Ptr IconSet ->                          -- icon_set : TInterface "Gtk" "IconSet"+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr Image)++{-# DEPRECATED imageNewFromIconSet ["(Since version 3.10)","Use gtk_image_new_from_icon_name() instead."]#-}+imageNewFromIconSet ::+    (MonadIO m) =>+    IconSet ->                              -- icon_set+    Int32 ->                                -- size+    m Image+imageNewFromIconSet icon_set size = liftIO $ do+    let icon_set' = unsafeManagedPtrGetPtr icon_set+    result <- gtk_image_new_from_icon_set icon_set' size+    checkUnexpectedReturnNULL "gtk_image_new_from_icon_set" result+    result' <- (newObject Image) result+    touchManagedPtr icon_set+    return result'++-- method Image::new_from_pixbuf+-- method type : Constructor+-- Args : [Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_pixbuf" gtk_image_new_from_pixbuf :: +    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO (Ptr Image)+++imageNewFromPixbuf ::+    (MonadIO m, GdkPixbuf.PixbufK a) =>+    Maybe (a) ->                            -- pixbuf+    m Image+imageNewFromPixbuf pixbuf = liftIO $ do+    maybePixbuf <- case pixbuf of+        Nothing -> return nullPtr+        Just jPixbuf -> do+            let jPixbuf' = unsafeManagedPtrCastPtr jPixbuf+            return jPixbuf'+    result <- gtk_image_new_from_pixbuf maybePixbuf+    checkUnexpectedReturnNULL "gtk_image_new_from_pixbuf" result+    result' <- (newObject Image) result+    whenJust pixbuf touchManagedPtr+    return result'++-- method Image::new_from_resource+-- method type : Constructor+-- Args : [Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_resource" gtk_image_new_from_resource :: +    CString ->                              -- resource_path : TBasicType TUTF8+    IO (Ptr Image)+++imageNewFromResource ::+    (MonadIO m) =>+    T.Text ->                               -- resource_path+    m Image+imageNewFromResource resource_path = liftIO $ do+    resource_path' <- textToCString resource_path+    result <- gtk_image_new_from_resource resource_path'+    checkUnexpectedReturnNULL "gtk_image_new_from_resource" result+    result' <- (newObject Image) result+    freeMem resource_path'+    return result'++-- method Image::new_from_stock+-- method type : Constructor+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_id", argType = TBasicType TUTF8, 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}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_stock" gtk_image_new_from_stock :: +    CString ->                              -- stock_id : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    IO (Ptr Image)++{-# DEPRECATED imageNewFromStock ["(Since version 3.10)","Use gtk_image_new_from_icon_name() instead."]#-}+imageNewFromStock ::+    (MonadIO m) =>+    T.Text ->                               -- stock_id+    Int32 ->                                -- size+    m Image+imageNewFromStock stock_id size = liftIO $ do+    stock_id' <- textToCString stock_id+    result <- gtk_image_new_from_stock stock_id' size+    checkUnexpectedReturnNULL "gtk_image_new_from_stock" result+    result' <- (newObject Image) result+    freeMem stock_id'+    return result'++-- method Image::new_from_surface+-- method type : Constructor+-- Args : [Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Image"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_new_from_surface" gtk_image_new_from_surface :: +    Ptr Cairo.Surface ->                    -- surface : TInterface "cairo" "Surface"+    IO (Ptr Image)+++imageNewFromSurface ::+    (MonadIO m) =>+    Maybe (Cairo.Surface) ->                -- surface+    m Image+imageNewFromSurface surface = liftIO $ do+    maybeSurface <- case surface of+        Nothing -> return nullPtr+        Just jSurface -> do+            let jSurface' = unsafeManagedPtrGetPtr jSurface+            return jSurface'+    result <- gtk_image_new_from_surface maybeSurface+    checkUnexpectedReturnNULL "gtk_image_new_from_surface" result+    result' <- (newObject Image) result+    whenJust surface touchManagedPtr+    return result'++-- method Image::clear+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_clear" gtk_image_clear :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    IO ()+++imageClear ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m ()+imageClear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_image_clear _obj'+    touchManagedPtr _obj+    return ()++-- method Image::get_animation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "PixbufAnimation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_animation" gtk_image_get_animation :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    IO (Ptr GdkPixbuf.PixbufAnimation)+++imageGetAnimation ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.PixbufAnimation+imageGetAnimation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_get_animation _obj'+    checkUnexpectedReturnNULL "gtk_image_get_animation" result+    result' <- (newObject GdkPixbuf.PixbufAnimation) result+    touchManagedPtr _obj+    return result'++-- method Image::get_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "gicon", argType = TInterface "Gio" "Icon", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_gicon" gtk_image_get_gicon :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr (Ptr Gio.Icon) ->                   -- gicon : TInterface "Gio" "Icon"+    Ptr Int32 ->                            -- size : TBasicType TInt32+    IO ()+++imageGetGicon ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m (Gio.Icon,Int32)+imageGetGicon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gicon <- allocMem :: IO (Ptr (Ptr Gio.Icon))+    size <- allocMem :: IO (Ptr Int32)+    gtk_image_get_gicon _obj' gicon size+    gicon' <- peek gicon+    gicon'' <- (newObject Gio.Icon) gicon'+    size' <- peek size+    touchManagedPtr _obj+    freeMem gicon+    freeMem size+    return (gicon'', size')++-- method Image::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_icon_name" gtk_image_get_icon_name :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr CString ->                          -- icon_name : TBasicType TUTF8+    Ptr Int32 ->                            -- size : TBasicType TInt32+    IO ()+++imageGetIconName ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m (T.Text,Int32)+imageGetIconName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name <- allocMem :: IO (Ptr CString)+    size <- allocMem :: IO (Ptr Int32)+    gtk_image_get_icon_name _obj' icon_name size+    icon_name' <- peek icon_name+    icon_name'' <- cstringToText icon_name'+    size' <- peek size+    touchManagedPtr _obj+    freeMem icon_name+    freeMem size+    return (icon_name'', size')++-- method Image::get_icon_set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_icon_set" gtk_image_get_icon_set :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr (Ptr IconSet) ->                    -- icon_set : TInterface "Gtk" "IconSet"+    Ptr Int32 ->                            -- size : TBasicType TInt32+    IO ()++{-# DEPRECATED imageGetIconSet ["(Since version 3.10)","Use gtk_image_get_icon_name() instead."]#-}+imageGetIconSet ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m (IconSet,Int32)+imageGetIconSet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_set <- allocMem :: IO (Ptr (Ptr IconSet))+    size <- allocMem :: IO (Ptr Int32)+    gtk_image_get_icon_set _obj' icon_set size+    icon_set' <- peek icon_set+    icon_set'' <- (newBoxed IconSet) icon_set'+    size' <- peek size+    touchManagedPtr _obj+    freeMem icon_set+    freeMem size+    return (icon_set'', size')++-- method Image::get_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_pixbuf" gtk_image_get_pixbuf :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    IO (Ptr GdkPixbuf.Pixbuf)+++imageGetPixbuf ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+imageGetPixbuf _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_get_pixbuf _obj'+    checkUnexpectedReturnNULL "gtk_image_get_pixbuf" result+    result' <- (newObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method Image::get_pixel_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_pixel_size" gtk_image_get_pixel_size :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    IO Int32+++imageGetPixelSize ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m Int32+imageGetPixelSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_get_pixel_size _obj'+    touchManagedPtr _obj+    return result++-- method Image::get_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_stock" gtk_image_get_stock :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr CString ->                          -- stock_id : TBasicType TUTF8+    Ptr Int32 ->                            -- size : TBasicType TInt32+    IO ()++{-# DEPRECATED imageGetStock ["(Since version 3.10)","Use gtk_image_get_icon_name() instead."]#-}+imageGetStock ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m (T.Text,Int32)+imageGetStock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stock_id <- allocMem :: IO (Ptr CString)+    size <- allocMem :: IO (Ptr Int32)+    gtk_image_get_stock _obj' stock_id size+    stock_id' <- peek stock_id+    stock_id'' <- cstringToText stock_id'+    size' <- peek size+    touchManagedPtr _obj+    freeMem stock_id+    freeMem size+    return (stock_id'', size')++-- method Image::get_storage_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ImageType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_get_storage_type" gtk_image_get_storage_type :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    IO CUInt+++imageGetStorageType ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    m ImageType+imageGetStorageType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_get_storage_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Image::set_from_animation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "animation", argType = TInterface "GdkPixbuf" "PixbufAnimation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "animation", argType = TInterface "GdkPixbuf" "PixbufAnimation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_animation" gtk_image_set_from_animation :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr GdkPixbuf.PixbufAnimation ->        -- animation : TInterface "GdkPixbuf" "PixbufAnimation"+    IO ()+++imageSetFromAnimation ::+    (MonadIO m, ImageK a, GdkPixbuf.PixbufAnimationK b) =>+    a ->                                    -- _obj+    b ->                                    -- animation+    m ()+imageSetFromAnimation _obj animation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let animation' = unsafeManagedPtrCastPtr animation+    gtk_image_set_from_animation _obj' animation'+    touchManagedPtr _obj+    touchManagedPtr animation+    return ()++-- method Image::set_from_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_file" gtk_image_set_from_file :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    CString ->                              -- filename : TBasicType TFileName+    IO ()+++imageSetFromFile ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    Maybe ([Char]) ->                       -- filename+    m ()+imageSetFromFile _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilename <- case filename of+        Nothing -> return nullPtr+        Just jFilename -> do+            jFilename' <- stringToCString jFilename+            return jFilename'+    gtk_image_set_from_file _obj' maybeFilename+    touchManagedPtr _obj+    freeMem maybeFilename+    return ()++-- method Image::set_from_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", 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},Arg {argName = "size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", 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},Arg {argName = "size", 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 "gtk_image_set_from_gicon" gtk_image_set_from_gicon :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    Int32 ->                                -- size : TBasicType TInt32+    IO ()+++imageSetFromGicon ::+    (MonadIO m, ImageK a, Gio.IconK b) =>+    a ->                                    -- _obj+    b ->                                    -- icon+    Int32 ->                                -- size+    m ()+imageSetFromGicon _obj icon size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon' = unsafeManagedPtrCastPtr icon+    gtk_image_set_from_gicon _obj' icon' size+    touchManagedPtr _obj+    touchManagedPtr icon+    return ()++-- method Image::set_from_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_icon_name" gtk_image_set_from_icon_name :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    CString ->                              -- icon_name : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    IO ()+++imageSetFromIconName ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon_name+    Int32 ->                                -- size+    m ()+imageSetFromIconName _obj icon_name size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon_name' <- textToCString icon_name+    gtk_image_set_from_icon_name _obj' icon_name' size+    touchManagedPtr _obj+    freeMem icon_name'+    return ()++-- method Image::set_from_icon_set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_set", argType = TInterface "Gtk" "IconSet", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_icon_set" gtk_image_set_from_icon_set :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr IconSet ->                          -- icon_set : TInterface "Gtk" "IconSet"+    Int32 ->                                -- size : TBasicType TInt32+    IO ()++{-# DEPRECATED imageSetFromIconSet ["(Since version 3.10)","Use gtk_image_set_from_icon_name() instead."]#-}+imageSetFromIconSet ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    IconSet ->                              -- icon_set+    Int32 ->                                -- size+    m ()+imageSetFromIconSet _obj icon_set size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let icon_set' = unsafeManagedPtrGetPtr icon_set+    gtk_image_set_from_icon_set _obj' icon_set' size+    touchManagedPtr _obj+    touchManagedPtr icon_set+    return ()++-- method Image::set_from_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixbuf", argType = TInterface "GdkPixbuf" "Pixbuf", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_pixbuf" gtk_image_set_from_pixbuf :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr GdkPixbuf.Pixbuf ->                 -- pixbuf : TInterface "GdkPixbuf" "Pixbuf"+    IO ()+++imageSetFromPixbuf ::+    (MonadIO m, ImageK a, GdkPixbuf.PixbufK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- pixbuf+    m ()+imageSetFromPixbuf _obj pixbuf = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePixbuf <- case pixbuf of+        Nothing -> return nullPtr+        Just jPixbuf -> do+            let jPixbuf' = unsafeManagedPtrCastPtr jPixbuf+            return jPixbuf'+    gtk_image_set_from_pixbuf _obj' maybePixbuf+    touchManagedPtr _obj+    whenJust pixbuf touchManagedPtr+    return ()++-- method Image::set_from_resource+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", 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 "Gtk" "Image", 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 "gtk_image_set_from_resource" gtk_image_set_from_resource :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    CString ->                              -- resource_path : TBasicType TUTF8+    IO ()+++imageSetFromResource ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- resource_path+    m ()+imageSetFromResource _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'+    gtk_image_set_from_resource _obj' maybeResource_path+    touchManagedPtr _obj+    freeMem maybeResource_path+    return ()++-- method Image::set_from_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_stock" gtk_image_set_from_stock :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    CString ->                              -- stock_id : TBasicType TUTF8+    Int32 ->                                -- size : TBasicType TInt32+    IO ()++{-# DEPRECATED imageSetFromStock ["(Since version 3.10)","Use gtk_image_set_from_icon_name() instead."]#-}+imageSetFromStock ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- stock_id+    Int32 ->                                -- size+    m ()+imageSetFromStock _obj stock_id size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    stock_id' <- textToCString stock_id+    gtk_image_set_from_stock _obj' stock_id' size+    touchManagedPtr _obj+    freeMem stock_id'+    return ()++-- method Image::set_from_surface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "surface", argType = TInterface "cairo" "Surface", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_set_from_surface" gtk_image_set_from_surface :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Ptr Cairo.Surface ->                    -- surface : TInterface "cairo" "Surface"+    IO ()+++imageSetFromSurface ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    Cairo.Surface ->                        -- surface+    m ()+imageSetFromSurface _obj surface = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let surface' = unsafeManagedPtrGetPtr surface+    gtk_image_set_from_surface _obj' surface'+    touchManagedPtr _obj+    touchManagedPtr surface+    return ()++-- method Image::set_pixel_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixel_size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Image", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pixel_size", 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 "gtk_image_set_pixel_size" gtk_image_set_pixel_size :: +    Ptr Image ->                            -- _obj : TInterface "Gtk" "Image"+    Int32 ->                                -- pixel_size : TBasicType TInt32+    IO ()+++imageSetPixelSize ::+    (MonadIO m, ImageK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- pixel_size+    m ()+imageSetPixelSize _obj pixel_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_image_set_pixel_size _obj' pixel_size+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Image.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gtk.Objects.Image where++import Prelude ()+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 Image = Image (ForeignPtr Image)+instance GObject Image where+class GObject o => ImageK o+instance (GObject o, IsDescendantOf Image o) => ImageK o+data ImageFilePropertyInfo+data ImageGiconPropertyInfo+data ImageIconNamePropertyInfo+data ImageIconSetPropertyInfo+data ImageIconSizePropertyInfo+data ImagePixbufPropertyInfo+data ImagePixbufAnimationPropertyInfo+data ImagePixelSizePropertyInfo+data ImageResourcePropertyInfo+data ImageStockPropertyInfo+data ImageStorageTypePropertyInfo+data ImageSurfacePropertyInfo+data ImageUseFallbackPropertyInfo
+ GI/Gtk/Objects/ImageAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ImageAccessible+    ( ++-- * Exported types+    ImageAccessible(..)                     ,+    ImageAccessibleK                        ,+    toImageAccessible                       ,+    noImageAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ImageAccessible = ImageAccessible (ForeignPtr ImageAccessible)+foreign import ccall "gtk_image_accessible_get_type"+    c_gtk_image_accessible_get_type :: IO GType++type instance ParentTypes ImageAccessible = ImageAccessibleParentTypes+type ImageAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Image]++instance GObject ImageAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_image_accessible_get_type+    ++class GObject o => ImageAccessibleK o+instance (GObject o, IsDescendantOf ImageAccessible o) => ImageAccessibleK o++toImageAccessible :: ImageAccessibleK o => o -> IO ImageAccessible+toImageAccessible = unsafeCastTo ImageAccessible++noImageAccessible :: Maybe ImageAccessible+noImageAccessible = Nothing++type instance AttributeList ImageAccessible = ImageAccessibleAttributeList+type ImageAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ImageAccessible = ImageAccessibleSignalList+type ImageAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ImageAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ImageAccessible where++import Prelude ()+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 ImageAccessible = ImageAccessible (ForeignPtr ImageAccessible)+instance GObject ImageAccessible where+class GObject o => ImageAccessibleK o+instance (GObject o, IsDescendantOf ImageAccessible o) => ImageAccessibleK o
+ GI/Gtk/Objects/ImageCellAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ImageCellAccessible+    ( ++-- * Exported types+    ImageCellAccessible(..)                 ,+    ImageCellAccessibleK                    ,+    toImageCellAccessible                   ,+    noImageCellAccessible                   ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ImageCellAccessible = ImageCellAccessible (ForeignPtr ImageCellAccessible)+foreign import ccall "gtk_image_cell_accessible_get_type"+    c_gtk_image_cell_accessible_get_type :: IO GType++type instance ParentTypes ImageCellAccessible = ImageCellAccessibleParentTypes+type ImageCellAccessibleParentTypes = '[RendererCellAccessible, CellAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Image]++instance GObject ImageCellAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_image_cell_accessible_get_type+    ++class GObject o => ImageCellAccessibleK o+instance (GObject o, IsDescendantOf ImageCellAccessible o) => ImageCellAccessibleK o++toImageCellAccessible :: ImageCellAccessibleK o => o -> IO ImageCellAccessible+toImageCellAccessible = unsafeCastTo ImageCellAccessible++noImageCellAccessible :: Maybe ImageCellAccessible+noImageCellAccessible = Nothing++type instance AttributeList ImageCellAccessible = ImageCellAccessibleAttributeList+type ImageCellAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("renderer", RendererCellAccessibleRendererPropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ImageCellAccessible = ImageCellAccessibleSignalList+type ImageCellAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ImageCellAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ImageCellAccessible where++import Prelude ()+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 ImageCellAccessible = ImageCellAccessible (ForeignPtr ImageCellAccessible)+instance GObject ImageCellAccessible where+class GObject o => ImageCellAccessibleK o+instance (GObject o, IsDescendantOf ImageCellAccessible o) => ImageCellAccessibleK o
+ GI/Gtk/Objects/ImageMenuItem.hs view
@@ -0,0 +1,527 @@++{- |+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.Gtk.Objects.ImageMenuItem+    ( ++-- * Exported types+    ImageMenuItem(..)                       ,+    ImageMenuItemK                          ,+    toImageMenuItem                         ,+    noImageMenuItem                         ,+++ -- * Methods+-- ** imageMenuItemGetAlwaysShowImage+    imageMenuItemGetAlwaysShowImage         ,+++-- ** imageMenuItemGetImage+    imageMenuItemGetImage                   ,+++-- ** imageMenuItemGetUseStock+    imageMenuItemGetUseStock                ,+++-- ** imageMenuItemNew+    imageMenuItemNew                        ,+++-- ** imageMenuItemNewFromStock+    imageMenuItemNewFromStock               ,+++-- ** imageMenuItemNewWithLabel+    imageMenuItemNewWithLabel               ,+++-- ** imageMenuItemNewWithMnemonic+    imageMenuItemNewWithMnemonic            ,+++-- ** imageMenuItemSetAccelGroup+    imageMenuItemSetAccelGroup              ,+++-- ** imageMenuItemSetAlwaysShowImage+    imageMenuItemSetAlwaysShowImage         ,+++-- ** imageMenuItemSetImage+    imageMenuItemSetImage                   ,+++-- ** imageMenuItemSetUseStock+    imageMenuItemSetUseStock                ,+++++ -- * Properties+-- ** AccelGroup+    ImageMenuItemAccelGroupPropertyInfo     ,+    constructImageMenuItemAccelGroup        ,+    setImageMenuItemAccelGroup              ,+++-- ** AlwaysShowImage+    ImageMenuItemAlwaysShowImagePropertyInfo,+    constructImageMenuItemAlwaysShowImage   ,+    getImageMenuItemAlwaysShowImage         ,+    setImageMenuItemAlwaysShowImage         ,+++-- ** Image+    ImageMenuItemImagePropertyInfo          ,+    constructImageMenuItemImage             ,+    getImageMenuItemImage                   ,+    setImageMenuItemImage                   ,+++-- ** UseStock+    ImageMenuItemUseStockPropertyInfo       ,+    constructImageMenuItemUseStock          ,+    getImageMenuItemUseStock                ,+    setImageMenuItemUseStock                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ImageMenuItem = ImageMenuItem (ForeignPtr ImageMenuItem)+foreign import ccall "gtk_image_menu_item_get_type"+    c_gtk_image_menu_item_get_type :: IO GType++type instance ParentTypes ImageMenuItem = ImageMenuItemParentTypes+type ImageMenuItemParentTypes = '[MenuItem, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject ImageMenuItem where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_image_menu_item_get_type+    ++class GObject o => ImageMenuItemK o+instance (GObject o, IsDescendantOf ImageMenuItem o) => ImageMenuItemK o++toImageMenuItem :: ImageMenuItemK o => o -> IO ImageMenuItem+toImageMenuItem = unsafeCastTo ImageMenuItem++noImageMenuItem :: Maybe ImageMenuItem+noImageMenuItem = Nothing++-- VVV Prop "accel-group"+   -- Type: TInterface "Gtk" "AccelGroup"+   -- Flags: [PropertyWritable]++setImageMenuItemAccelGroup :: (MonadIO m, ImageMenuItemK o, AccelGroupK a) => o -> a -> m ()+setImageMenuItemAccelGroup obj val = liftIO $ setObjectPropertyObject obj "accel-group" val++constructImageMenuItemAccelGroup :: (AccelGroupK a) => a -> IO ([Char], GValue)+constructImageMenuItemAccelGroup val = constructObjectPropertyObject "accel-group" val++data ImageMenuItemAccelGroupPropertyInfo+instance AttrInfo ImageMenuItemAccelGroupPropertyInfo where+    type AttrAllowedOps ImageMenuItemAccelGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint ImageMenuItemAccelGroupPropertyInfo = AccelGroupK+    type AttrBaseTypeConstraint ImageMenuItemAccelGroupPropertyInfo = ImageMenuItemK+    type AttrGetType ImageMenuItemAccelGroupPropertyInfo = ()+    type AttrLabel ImageMenuItemAccelGroupPropertyInfo = "ImageMenuItem::accel-group"+    attrGet _ = undefined+    attrSet _ = setImageMenuItemAccelGroup+    attrConstruct _ = constructImageMenuItemAccelGroup++-- VVV Prop "always-show-image"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getImageMenuItemAlwaysShowImage :: (MonadIO m, ImageMenuItemK o) => o -> m Bool+getImageMenuItemAlwaysShowImage obj = liftIO $ getObjectPropertyBool obj "always-show-image"++setImageMenuItemAlwaysShowImage :: (MonadIO m, ImageMenuItemK o) => o -> Bool -> m ()+setImageMenuItemAlwaysShowImage obj val = liftIO $ setObjectPropertyBool obj "always-show-image" val++constructImageMenuItemAlwaysShowImage :: Bool -> IO ([Char], GValue)+constructImageMenuItemAlwaysShowImage val = constructObjectPropertyBool "always-show-image" val++data ImageMenuItemAlwaysShowImagePropertyInfo+instance AttrInfo ImageMenuItemAlwaysShowImagePropertyInfo where+    type AttrAllowedOps ImageMenuItemAlwaysShowImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageMenuItemAlwaysShowImagePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ImageMenuItemAlwaysShowImagePropertyInfo = ImageMenuItemK+    type AttrGetType ImageMenuItemAlwaysShowImagePropertyInfo = Bool+    type AttrLabel ImageMenuItemAlwaysShowImagePropertyInfo = "ImageMenuItem::always-show-image"+    attrGet _ = getImageMenuItemAlwaysShowImage+    attrSet _ = setImageMenuItemAlwaysShowImage+    attrConstruct _ = constructImageMenuItemAlwaysShowImage++-- VVV Prop "image"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getImageMenuItemImage :: (MonadIO m, ImageMenuItemK o) => o -> m Widget+getImageMenuItemImage obj = liftIO $ getObjectPropertyObject obj "image" Widget++setImageMenuItemImage :: (MonadIO m, ImageMenuItemK o, WidgetK a) => o -> a -> m ()+setImageMenuItemImage obj val = liftIO $ setObjectPropertyObject obj "image" val++constructImageMenuItemImage :: (WidgetK a) => a -> IO ([Char], GValue)+constructImageMenuItemImage val = constructObjectPropertyObject "image" val++data ImageMenuItemImagePropertyInfo+instance AttrInfo ImageMenuItemImagePropertyInfo where+    type AttrAllowedOps ImageMenuItemImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageMenuItemImagePropertyInfo = WidgetK+    type AttrBaseTypeConstraint ImageMenuItemImagePropertyInfo = ImageMenuItemK+    type AttrGetType ImageMenuItemImagePropertyInfo = Widget+    type AttrLabel ImageMenuItemImagePropertyInfo = "ImageMenuItem::image"+    attrGet _ = getImageMenuItemImage+    attrSet _ = setImageMenuItemImage+    attrConstruct _ = constructImageMenuItemImage++-- VVV Prop "use-stock"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getImageMenuItemUseStock :: (MonadIO m, ImageMenuItemK o) => o -> m Bool+getImageMenuItemUseStock obj = liftIO $ getObjectPropertyBool obj "use-stock"++setImageMenuItemUseStock :: (MonadIO m, ImageMenuItemK o) => o -> Bool -> m ()+setImageMenuItemUseStock obj val = liftIO $ setObjectPropertyBool obj "use-stock" val++constructImageMenuItemUseStock :: Bool -> IO ([Char], GValue)+constructImageMenuItemUseStock val = constructObjectPropertyBool "use-stock" val++data ImageMenuItemUseStockPropertyInfo+instance AttrInfo ImageMenuItemUseStockPropertyInfo where+    type AttrAllowedOps ImageMenuItemUseStockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ImageMenuItemUseStockPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ImageMenuItemUseStockPropertyInfo = ImageMenuItemK+    type AttrGetType ImageMenuItemUseStockPropertyInfo = Bool+    type AttrLabel ImageMenuItemUseStockPropertyInfo = "ImageMenuItem::use-stock"+    attrGet _ = getImageMenuItemUseStock+    attrSet _ = setImageMenuItemUseStock+    attrConstruct _ = constructImageMenuItemUseStock++type instance AttributeList ImageMenuItem = ImageMenuItemAttributeList+type ImageMenuItemAttributeList = ('[ '("accel-group", ImageMenuItemAccelGroupPropertyInfo), '("accel-path", MenuItemAccelPathPropertyInfo), '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("always-show-image", ImageMenuItemAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ImageMenuItemImagePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", MenuItemLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("right-justified", MenuItemRightJustifiedPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("submenu", MenuItemSubmenuPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ImageMenuItemUseStockPropertyInfo), '("use-underline", MenuItemUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ImageMenuItem = ImageMenuItemSignalList+type ImageMenuItemSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", MenuItemActivateSignalInfo), '("activate-item", MenuItemActivateItemSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("deselect", MenuItemDeselectSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select", MenuItemSelectSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-size-allocate", MenuItemToggleSizeAllocateSignalInfo), '("toggle-size-request", MenuItemToggleSizeRequestSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ImageMenuItem::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ImageMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_new" gtk_image_menu_item_new :: +    IO (Ptr ImageMenuItem)++{-# DEPRECATED imageMenuItemNew ["(Since version 3.10)","Use gtk_menu_item_new() instead."]#-}+imageMenuItemNew ::+    (MonadIO m) =>+    m ImageMenuItem+imageMenuItemNew  = liftIO $ do+    result <- gtk_image_menu_item_new+    checkUnexpectedReturnNULL "gtk_image_menu_item_new" result+    result' <- (newObject ImageMenuItem) result+    return result'++-- method ImageMenuItem::new_from_stock+-- method type : Constructor+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ImageMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_new_from_stock" gtk_image_menu_item_new_from_stock :: +    CString ->                              -- stock_id : TBasicType TUTF8+    Ptr AccelGroup ->                       -- accel_group : TInterface "Gtk" "AccelGroup"+    IO (Ptr ImageMenuItem)++{-# DEPRECATED imageMenuItemNewFromStock ["(Since version 3.10)","Use gtk_menu_item_new_with_mnemonic() instead."]#-}+imageMenuItemNewFromStock ::+    (MonadIO m, AccelGroupK a) =>+    T.Text ->                               -- stock_id+    Maybe (a) ->                            -- accel_group+    m ImageMenuItem+imageMenuItemNewFromStock stock_id accel_group = liftIO $ do+    stock_id' <- textToCString stock_id+    maybeAccel_group <- case accel_group of+        Nothing -> return nullPtr+        Just jAccel_group -> do+            let jAccel_group' = unsafeManagedPtrCastPtr jAccel_group+            return jAccel_group'+    result <- gtk_image_menu_item_new_from_stock stock_id' maybeAccel_group+    checkUnexpectedReturnNULL "gtk_image_menu_item_new_from_stock" result+    result' <- (newObject ImageMenuItem) result+    whenJust accel_group touchManagedPtr+    freeMem stock_id'+    return result'++-- method ImageMenuItem::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ImageMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_new_with_label" gtk_image_menu_item_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr ImageMenuItem)++{-# DEPRECATED imageMenuItemNewWithLabel ["(Since version 3.10)","Use gtk_menu_item_new_with_label() instead."]#-}+imageMenuItemNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m ImageMenuItem+imageMenuItemNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- gtk_image_menu_item_new_with_label label'+    checkUnexpectedReturnNULL "gtk_image_menu_item_new_with_label" result+    result' <- (newObject ImageMenuItem) result+    freeMem label'+    return result'++-- method ImageMenuItem::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ImageMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_new_with_mnemonic" gtk_image_menu_item_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr ImageMenuItem)++{-# DEPRECATED imageMenuItemNewWithMnemonic ["(Since version 3.10)","Use gtk_menu_item_new_with_mnemonic() instead."]#-}+imageMenuItemNewWithMnemonic ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m ImageMenuItem+imageMenuItemNewWithMnemonic label = liftIO $ do+    label' <- textToCString label+    result <- gtk_image_menu_item_new_with_mnemonic label'+    checkUnexpectedReturnNULL "gtk_image_menu_item_new_with_mnemonic" result+    result' <- (newObject ImageMenuItem) result+    freeMem label'+    return result'++-- method ImageMenuItem::get_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_get_always_show_image" gtk_image_menu_item_get_always_show_image :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    IO CInt++{-# DEPRECATED imageMenuItemGetAlwaysShowImage ["(Since version 3.10)"]#-}+imageMenuItemGetAlwaysShowImage ::+    (MonadIO m, ImageMenuItemK a) =>+    a ->                                    -- _obj+    m Bool+imageMenuItemGetAlwaysShowImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_menu_item_get_always_show_image _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ImageMenuItem::get_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_get_image" gtk_image_menu_item_get_image :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    IO (Ptr Widget)++{-# DEPRECATED imageMenuItemGetImage ["(Since version 3.10)"]#-}+imageMenuItemGetImage ::+    (MonadIO m, ImageMenuItemK a) =>+    a ->                                    -- _obj+    m Widget+imageMenuItemGetImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_menu_item_get_image _obj'+    checkUnexpectedReturnNULL "gtk_image_menu_item_get_image" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method ImageMenuItem::get_use_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_get_use_stock" gtk_image_menu_item_get_use_stock :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    IO CInt++{-# DEPRECATED imageMenuItemGetUseStock ["(Since version 3.10)"]#-}+imageMenuItemGetUseStock ::+    (MonadIO m, ImageMenuItemK a) =>+    a ->                                    -- _obj+    m Bool+imageMenuItemGetUseStock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_image_menu_item_get_use_stock _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ImageMenuItem::set_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_set_accel_group" gtk_image_menu_item_set_accel_group :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    Ptr AccelGroup ->                       -- accel_group : TInterface "Gtk" "AccelGroup"+    IO ()++{-# DEPRECATED imageMenuItemSetAccelGroup ["(Since version 3.10)"]#-}+imageMenuItemSetAccelGroup ::+    (MonadIO m, ImageMenuItemK a, AccelGroupK b) =>+    a ->                                    -- _obj+    b ->                                    -- accel_group+    m ()+imageMenuItemSetAccelGroup _obj accel_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let accel_group' = unsafeManagedPtrCastPtr accel_group+    gtk_image_menu_item_set_accel_group _obj' accel_group'+    touchManagedPtr _obj+    touchManagedPtr accel_group+    return ()++-- method ImageMenuItem::set_always_show_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "always_show", 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 "gtk_image_menu_item_set_always_show_image" gtk_image_menu_item_set_always_show_image :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    CInt ->                                 -- always_show : TBasicType TBoolean+    IO ()++{-# DEPRECATED imageMenuItemSetAlwaysShowImage ["(Since version 3.10)"]#-}+imageMenuItemSetAlwaysShowImage ::+    (MonadIO m, ImageMenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- always_show+    m ()+imageMenuItemSetAlwaysShowImage _obj always_show = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let always_show' = (fromIntegral . fromEnum) always_show+    gtk_image_menu_item_set_always_show_image _obj' always_show'+    touchManagedPtr _obj+    return ()++-- method ImageMenuItem::set_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_image_menu_item_set_image" gtk_image_menu_item_set_image :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    Ptr Widget ->                           -- image : TInterface "Gtk" "Widget"+    IO ()++{-# DEPRECATED imageMenuItemSetImage ["(Since version 3.10)"]#-}+imageMenuItemSetImage ::+    (MonadIO m, ImageMenuItemK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- image+    m ()+imageMenuItemSetImage _obj image = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeImage <- case image of+        Nothing -> return nullPtr+        Just jImage -> do+            let jImage' = unsafeManagedPtrCastPtr jImage+            return jImage'+    gtk_image_menu_item_set_image _obj' maybeImage+    touchManagedPtr _obj+    whenJust image touchManagedPtr+    return ()++-- method ImageMenuItem::set_use_stock+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_stock", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ImageMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_stock", 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 "gtk_image_menu_item_set_use_stock" gtk_image_menu_item_set_use_stock :: +    Ptr ImageMenuItem ->                    -- _obj : TInterface "Gtk" "ImageMenuItem"+    CInt ->                                 -- use_stock : TBasicType TBoolean+    IO ()++{-# DEPRECATED imageMenuItemSetUseStock ["(Since version 3.10)"]#-}+imageMenuItemSetUseStock ::+    (MonadIO m, ImageMenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_stock+    m ()+imageMenuItemSetUseStock _obj use_stock = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_stock' = (fromIntegral . fromEnum) use_stock+    gtk_image_menu_item_set_use_stock _obj' use_stock'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ImageMenuItem.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.ImageMenuItem where++import Prelude ()+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 ImageMenuItem = ImageMenuItem (ForeignPtr ImageMenuItem)+instance GObject ImageMenuItem where+class GObject o => ImageMenuItemK o+instance (GObject o, IsDescendantOf ImageMenuItem o) => ImageMenuItemK o+data ImageMenuItemAccelGroupPropertyInfo+data ImageMenuItemAlwaysShowImagePropertyInfo+data ImageMenuItemImagePropertyInfo+data ImageMenuItemUseStockPropertyInfo
+ GI/Gtk/Objects/InfoBar.hs view
@@ -0,0 +1,612 @@++{- |+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.Gtk.Objects.InfoBar+    ( ++-- * Exported types+    InfoBar(..)                             ,+    InfoBarK                                ,+    toInfoBar                               ,+    noInfoBar                               ,+++ -- * Methods+-- ** infoBarAddActionWidget+    infoBarAddActionWidget                  ,+++-- ** infoBarAddButton+    infoBarAddButton                        ,+++-- ** infoBarGetActionArea+    infoBarGetActionArea                    ,+++-- ** infoBarGetContentArea+    infoBarGetContentArea                   ,+++-- ** infoBarGetMessageType+    infoBarGetMessageType                   ,+++-- ** infoBarGetShowCloseButton+    infoBarGetShowCloseButton               ,+++-- ** infoBarNew+    infoBarNew                              ,+++-- ** infoBarResponse+    infoBarResponse                         ,+++-- ** infoBarSetDefaultResponse+    infoBarSetDefaultResponse               ,+++-- ** infoBarSetMessageType+    infoBarSetMessageType                   ,+++-- ** infoBarSetResponseSensitive+    infoBarSetResponseSensitive             ,+++-- ** infoBarSetShowCloseButton+    infoBarSetShowCloseButton               ,+++++ -- * Properties+-- ** MessageType+    InfoBarMessageTypePropertyInfo          ,+    constructInfoBarMessageType             ,+    getInfoBarMessageType                   ,+    setInfoBarMessageType                   ,+++-- ** ShowCloseButton+    InfoBarShowCloseButtonPropertyInfo      ,+    constructInfoBarShowCloseButton         ,+    getInfoBarShowCloseButton               ,+    setInfoBarShowCloseButton               ,+++++ -- * Signals+-- ** Close+    InfoBarCloseCallback                    ,+    InfoBarCloseCallbackC                   ,+    InfoBarCloseSignalInfo                  ,+    afterInfoBarClose                       ,+    infoBarCloseCallbackWrapper             ,+    infoBarCloseClosure                     ,+    mkInfoBarCloseCallback                  ,+    noInfoBarCloseCallback                  ,+    onInfoBarClose                          ,+++-- ** Response+    InfoBarResponseCallback                 ,+    InfoBarResponseCallbackC                ,+    InfoBarResponseSignalInfo               ,+    afterInfoBarResponse                    ,+    infoBarResponseCallbackWrapper          ,+    infoBarResponseClosure                  ,+    mkInfoBarResponseCallback               ,+    noInfoBarResponseCallback               ,+    onInfoBarResponse                       ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype InfoBar = InfoBar (ForeignPtr InfoBar)+foreign import ccall "gtk_info_bar_get_type"+    c_gtk_info_bar_get_type :: IO GType++type instance ParentTypes InfoBar = InfoBarParentTypes+type InfoBarParentTypes = '[Box, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject InfoBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_info_bar_get_type+    ++class GObject o => InfoBarK o+instance (GObject o, IsDescendantOf InfoBar o) => InfoBarK o++toInfoBar :: InfoBarK o => o -> IO InfoBar+toInfoBar = unsafeCastTo InfoBar++noInfoBar :: Maybe InfoBar+noInfoBar = Nothing++-- signal InfoBar::close+type InfoBarCloseCallback =+    IO ()++noInfoBarCloseCallback :: Maybe InfoBarCloseCallback+noInfoBarCloseCallback = Nothing++type InfoBarCloseCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkInfoBarCloseCallback :: InfoBarCloseCallbackC -> IO (FunPtr InfoBarCloseCallbackC)++infoBarCloseClosure :: InfoBarCloseCallback -> IO Closure+infoBarCloseClosure cb = newCClosure =<< mkInfoBarCloseCallback wrapped+    where wrapped = infoBarCloseCallbackWrapper cb++infoBarCloseCallbackWrapper ::+    InfoBarCloseCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+infoBarCloseCallbackWrapper _cb _ _ = do+    _cb ++onInfoBarClose :: (GObject a, MonadIO m) => a -> InfoBarCloseCallback -> m SignalHandlerId+onInfoBarClose obj cb = liftIO $ connectInfoBarClose obj cb SignalConnectBefore+afterInfoBarClose :: (GObject a, MonadIO m) => a -> InfoBarCloseCallback -> m SignalHandlerId+afterInfoBarClose obj cb = connectInfoBarClose obj cb SignalConnectAfter++connectInfoBarClose :: (GObject a, MonadIO m) =>+                       a -> InfoBarCloseCallback -> SignalConnectMode -> m SignalHandlerId+connectInfoBarClose obj cb after = liftIO $ do+    cb' <- mkInfoBarCloseCallback (infoBarCloseCallbackWrapper cb)+    connectSignalFunPtr obj "close" cb' after++-- signal InfoBar::response+type InfoBarResponseCallback =+    Int32 ->+    IO ()++noInfoBarResponseCallback :: Maybe InfoBarResponseCallback+noInfoBarResponseCallback = Nothing++type InfoBarResponseCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkInfoBarResponseCallback :: InfoBarResponseCallbackC -> IO (FunPtr InfoBarResponseCallbackC)++infoBarResponseClosure :: InfoBarResponseCallback -> IO Closure+infoBarResponseClosure cb = newCClosure =<< mkInfoBarResponseCallback wrapped+    where wrapped = infoBarResponseCallbackWrapper cb++infoBarResponseCallbackWrapper ::+    InfoBarResponseCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+infoBarResponseCallbackWrapper _cb _ response_id _ = do+    _cb  response_id++onInfoBarResponse :: (GObject a, MonadIO m) => a -> InfoBarResponseCallback -> m SignalHandlerId+onInfoBarResponse obj cb = liftIO $ connectInfoBarResponse obj cb SignalConnectBefore+afterInfoBarResponse :: (GObject a, MonadIO m) => a -> InfoBarResponseCallback -> m SignalHandlerId+afterInfoBarResponse obj cb = connectInfoBarResponse obj cb SignalConnectAfter++connectInfoBarResponse :: (GObject a, MonadIO m) =>+                          a -> InfoBarResponseCallback -> SignalConnectMode -> m SignalHandlerId+connectInfoBarResponse obj cb after = liftIO $ do+    cb' <- mkInfoBarResponseCallback (infoBarResponseCallbackWrapper cb)+    connectSignalFunPtr obj "response" cb' after++-- VVV Prop "message-type"+   -- Type: TInterface "Gtk" "MessageType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getInfoBarMessageType :: (MonadIO m, InfoBarK o) => o -> m MessageType+getInfoBarMessageType obj = liftIO $ getObjectPropertyEnum obj "message-type"++setInfoBarMessageType :: (MonadIO m, InfoBarK o) => o -> MessageType -> m ()+setInfoBarMessageType obj val = liftIO $ setObjectPropertyEnum obj "message-type" val++constructInfoBarMessageType :: MessageType -> IO ([Char], GValue)+constructInfoBarMessageType val = constructObjectPropertyEnum "message-type" val++data InfoBarMessageTypePropertyInfo+instance AttrInfo InfoBarMessageTypePropertyInfo where+    type AttrAllowedOps InfoBarMessageTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InfoBarMessageTypePropertyInfo = (~) MessageType+    type AttrBaseTypeConstraint InfoBarMessageTypePropertyInfo = InfoBarK+    type AttrGetType InfoBarMessageTypePropertyInfo = MessageType+    type AttrLabel InfoBarMessageTypePropertyInfo = "InfoBar::message-type"+    attrGet _ = getInfoBarMessageType+    attrSet _ = setInfoBarMessageType+    attrConstruct _ = constructInfoBarMessageType++-- VVV Prop "show-close-button"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getInfoBarShowCloseButton :: (MonadIO m, InfoBarK o) => o -> m Bool+getInfoBarShowCloseButton obj = liftIO $ getObjectPropertyBool obj "show-close-button"++setInfoBarShowCloseButton :: (MonadIO m, InfoBarK o) => o -> Bool -> m ()+setInfoBarShowCloseButton obj val = liftIO $ setObjectPropertyBool obj "show-close-button" val++constructInfoBarShowCloseButton :: Bool -> IO ([Char], GValue)+constructInfoBarShowCloseButton val = constructObjectPropertyBool "show-close-button" val++data InfoBarShowCloseButtonPropertyInfo+instance AttrInfo InfoBarShowCloseButtonPropertyInfo where+    type AttrAllowedOps InfoBarShowCloseButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InfoBarShowCloseButtonPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint InfoBarShowCloseButtonPropertyInfo = InfoBarK+    type AttrGetType InfoBarShowCloseButtonPropertyInfo = Bool+    type AttrLabel InfoBarShowCloseButtonPropertyInfo = "InfoBar::show-close-button"+    attrGet _ = getInfoBarShowCloseButton+    attrSet _ = setInfoBarShowCloseButton+    attrConstruct _ = constructInfoBarShowCloseButton++type instance AttributeList InfoBar = InfoBarAttributeList+type InfoBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("baseline-position", BoxBaselinePositionPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("homogeneous", BoxHomogeneousPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("message-type", InfoBarMessageTypePropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-close-button", InfoBarShowCloseButtonPropertyInfo), '("spacing", BoxSpacingPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data InfoBarCloseSignalInfo+instance SignalInfo InfoBarCloseSignalInfo where+    type HaskellCallbackType InfoBarCloseSignalInfo = InfoBarCloseCallback+    connectSignal _ = connectInfoBarClose++data InfoBarResponseSignalInfo+instance SignalInfo InfoBarResponseSignalInfo where+    type HaskellCallbackType InfoBarResponseSignalInfo = InfoBarResponseCallback+    connectSignal _ = connectInfoBarResponse++type instance SignalList InfoBar = InfoBarSignalList+type InfoBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", InfoBarCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", InfoBarResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method InfoBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "InfoBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_new" gtk_info_bar_new :: +    IO (Ptr InfoBar)+++infoBarNew ::+    (MonadIO m) =>+    m InfoBar+infoBarNew  = liftIO $ do+    result <- gtk_info_bar_new+    checkUnexpectedReturnNULL "gtk_info_bar_new" result+    result' <- (newObject InfoBar) result+    return result'++-- method InfoBar::add_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_info_bar_add_action_widget" gtk_info_bar_add_action_widget :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++infoBarAddActionWidget ::+    (MonadIO m, InfoBarK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- response_id+    m ()+infoBarAddActionWidget _obj child response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_info_bar_add_action_widget _obj' child' response_id+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method InfoBar::add_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Button"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_add_button" gtk_info_bar_add_button :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    CString ->                              -- button_text : TBasicType TUTF8+    Int32 ->                                -- response_id : TBasicType TInt32+    IO (Ptr Button)+++infoBarAddButton ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- button_text+    Int32 ->                                -- response_id+    m Button+infoBarAddButton _obj button_text response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    button_text' <- textToCString button_text+    result <- gtk_info_bar_add_button _obj' button_text' response_id+    checkUnexpectedReturnNULL "gtk_info_bar_add_button" result+    result' <- (newObject Button) result+    touchManagedPtr _obj+    freeMem button_text'+    return result'++-- method InfoBar::get_action_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_get_action_area" gtk_info_bar_get_action_area :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    IO (Ptr Widget)+++infoBarGetActionArea ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    m Widget+infoBarGetActionArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_info_bar_get_action_area _obj'+    checkUnexpectedReturnNULL "gtk_info_bar_get_action_area" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method InfoBar::get_content_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_get_content_area" gtk_info_bar_get_content_area :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    IO (Ptr Widget)+++infoBarGetContentArea ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    m Widget+infoBarGetContentArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_info_bar_get_content_area _obj'+    checkUnexpectedReturnNULL "gtk_info_bar_get_content_area" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method InfoBar::get_message_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MessageType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_get_message_type" gtk_info_bar_get_message_type :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    IO CUInt+++infoBarGetMessageType ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    m MessageType+infoBarGetMessageType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_info_bar_get_message_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method InfoBar::get_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_get_show_close_button" gtk_info_bar_get_show_close_button :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    IO CInt+++infoBarGetShowCloseButton ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    m Bool+infoBarGetShowCloseButton _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_info_bar_get_show_close_button _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method InfoBar::response+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_info_bar_response" gtk_info_bar_response :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++infoBarResponse ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    m ()+infoBarResponse _obj response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_info_bar_response _obj' response_id+    touchManagedPtr _obj+    return ()++-- method InfoBar::set_default_response+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", 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 "gtk_info_bar_set_default_response" gtk_info_bar_set_default_response :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    Int32 ->                                -- response_id : TBasicType TInt32+    IO ()+++infoBarSetDefaultResponse ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    m ()+infoBarSetDefaultResponse _obj response_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_info_bar_set_default_response _obj' response_id+    touchManagedPtr _obj+    return ()++-- method InfoBar::set_message_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message_type", argType = TInterface "Gtk" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "message_type", argType = TInterface "Gtk" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_info_bar_set_message_type" gtk_info_bar_set_message_type :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    CUInt ->                                -- message_type : TInterface "Gtk" "MessageType"+    IO ()+++infoBarSetMessageType ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    MessageType ->                          -- message_type+    m ()+infoBarSetMessageType _obj message_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message_type' = (fromIntegral . fromEnum) message_type+    gtk_info_bar_set_message_type _obj' message_type'+    touchManagedPtr _obj+    return ()++-- method InfoBar::set_response_sensitive+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "response_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_info_bar_set_response_sensitive" gtk_info_bar_set_response_sensitive :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    Int32 ->                                -- response_id : TBasicType TInt32+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++infoBarSetResponseSensitive ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- response_id+    Bool ->                                 -- setting+    m ()+infoBarSetResponseSensitive _obj response_id setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_info_bar_set_response_sensitive _obj' response_id setting'+    touchManagedPtr _obj+    return ()++-- method InfoBar::set_show_close_button+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "InfoBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_info_bar_set_show_close_button" gtk_info_bar_set_show_close_button :: +    Ptr InfoBar ->                          -- _obj : TInterface "Gtk" "InfoBar"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++infoBarSetShowCloseButton ::+    (MonadIO m, InfoBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+infoBarSetShowCloseButton _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_info_bar_set_show_close_button _obj' setting'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/InfoBar.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.InfoBar where++import Prelude ()+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 InfoBar = InfoBar (ForeignPtr InfoBar)+instance GObject InfoBar where+class GObject o => InfoBarK o+instance (GObject o, IsDescendantOf InfoBar o) => InfoBarK o+data InfoBarMessageTypePropertyInfo+data InfoBarShowCloseButtonPropertyInfo+data InfoBarCloseSignalInfo+data InfoBarResponseSignalInfo
+ GI/Gtk/Objects/Invisible.hs view
@@ -0,0 +1,215 @@++{- |+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.Gtk.Objects.Invisible+    ( ++-- * Exported types+    Invisible(..)                           ,+    InvisibleK                              ,+    toInvisible                             ,+    noInvisible                             ,+++ -- * Methods+-- ** invisibleGetScreen+    invisibleGetScreen                      ,+++-- ** invisibleNew+    invisibleNew                            ,+++-- ** invisibleNewForScreen+    invisibleNewForScreen                   ,+++-- ** invisibleSetScreen+    invisibleSetScreen                      ,+++++ -- * Properties+-- ** Screen+    InvisibleScreenPropertyInfo             ,+    constructInvisibleScreen                ,+    getInvisibleScreen                      ,+    setInvisibleScreen                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Invisible = Invisible (ForeignPtr Invisible)+foreign import ccall "gtk_invisible_get_type"+    c_gtk_invisible_get_type :: IO GType++type instance ParentTypes Invisible = InvisibleParentTypes+type InvisibleParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Invisible where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_invisible_get_type+    ++class GObject o => InvisibleK o+instance (GObject o, IsDescendantOf Invisible o) => InvisibleK o++toInvisible :: InvisibleK o => o -> IO Invisible+toInvisible = unsafeCastTo Invisible++noInvisible :: Maybe Invisible+noInvisible = Nothing++-- VVV Prop "screen"+   -- Type: TInterface "Gdk" "Screen"+   -- Flags: [PropertyReadable,PropertyWritable]++getInvisibleScreen :: (MonadIO m, InvisibleK o) => o -> m Gdk.Screen+getInvisibleScreen obj = liftIO $ getObjectPropertyObject obj "screen" Gdk.Screen++setInvisibleScreen :: (MonadIO m, InvisibleK o, Gdk.ScreenK a) => o -> a -> m ()+setInvisibleScreen obj val = liftIO $ setObjectPropertyObject obj "screen" val++constructInvisibleScreen :: (Gdk.ScreenK a) => a -> IO ([Char], GValue)+constructInvisibleScreen val = constructObjectPropertyObject "screen" val++data InvisibleScreenPropertyInfo+instance AttrInfo InvisibleScreenPropertyInfo where+    type AttrAllowedOps InvisibleScreenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint InvisibleScreenPropertyInfo = Gdk.ScreenK+    type AttrBaseTypeConstraint InvisibleScreenPropertyInfo = InvisibleK+    type AttrGetType InvisibleScreenPropertyInfo = Gdk.Screen+    type AttrLabel InvisibleScreenPropertyInfo = "Invisible::screen"+    attrGet _ = getInvisibleScreen+    attrSet _ = setInvisibleScreen+    attrConstruct _ = constructInvisibleScreen++type instance AttributeList Invisible = InvisibleAttributeList+type InvisibleAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", InvisibleScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Invisible = InvisibleSignalList+type InvisibleSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Invisible::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Invisible"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_invisible_new" gtk_invisible_new :: +    IO (Ptr Invisible)+++invisibleNew ::+    (MonadIO m) =>+    m Invisible+invisibleNew  = liftIO $ do+    result <- gtk_invisible_new+    checkUnexpectedReturnNULL "gtk_invisible_new" result+    result' <- (newObject Invisible) result+    return result'++-- method Invisible::new_for_screen+-- method type : Constructor+-- Args : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Invisible"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_invisible_new_for_screen" gtk_invisible_new_for_screen :: +    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO (Ptr Invisible)+++invisibleNewForScreen ::+    (MonadIO m, Gdk.ScreenK a) =>+    a ->                                    -- screen+    m Invisible+invisibleNewForScreen screen = liftIO $ do+    let screen' = unsafeManagedPtrCastPtr screen+    result <- gtk_invisible_new_for_screen screen'+    checkUnexpectedReturnNULL "gtk_invisible_new_for_screen" result+    result' <- (newObject Invisible) result+    touchManagedPtr screen+    return result'++-- method Invisible::get_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Invisible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Invisible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Screen"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_invisible_get_screen" gtk_invisible_get_screen :: +    Ptr Invisible ->                        -- _obj : TInterface "Gtk" "Invisible"+    IO (Ptr Gdk.Screen)+++invisibleGetScreen ::+    (MonadIO m, InvisibleK a) =>+    a ->                                    -- _obj+    m Gdk.Screen+invisibleGetScreen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_invisible_get_screen _obj'+    checkUnexpectedReturnNULL "gtk_invisible_get_screen" result+    result' <- (newObject Gdk.Screen) result+    touchManagedPtr _obj+    return result'++-- method Invisible::set_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Invisible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Invisible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_invisible_set_screen" gtk_invisible_set_screen :: +    Ptr Invisible ->                        -- _obj : TInterface "Gtk" "Invisible"+    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO ()+++invisibleSetScreen ::+    (MonadIO m, InvisibleK a, Gdk.ScreenK b) =>+    a ->                                    -- _obj+    b ->                                    -- screen+    m ()+invisibleSetScreen _obj screen = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let screen' = unsafeManagedPtrCastPtr screen+    gtk_invisible_set_screen _obj' screen'+    touchManagedPtr _obj+    touchManagedPtr screen+    return ()++
+ GI/Gtk/Objects/Invisible.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.Invisible where++import Prelude ()+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 Invisible = Invisible (ForeignPtr Invisible)+instance GObject Invisible where+class GObject o => InvisibleK o+instance (GObject o, IsDescendantOf Invisible o) => InvisibleK o+data InvisibleScreenPropertyInfo
+ GI/Gtk/Objects/Label.hs view
@@ -0,0 +1,2564 @@++{- |+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.Gtk.Objects.Label+    ( ++-- * Exported types+    Label(..)                               ,+    LabelK                                  ,+    toLabel                                 ,+    noLabel                                 ,+++ -- * Methods+-- ** labelGetAngle+    labelGetAngle                           ,+++-- ** labelGetAttributes+    labelGetAttributes                      ,+++-- ** labelGetCurrentUri+    labelGetCurrentUri                      ,+++-- ** labelGetEllipsize+    labelGetEllipsize                       ,+++-- ** labelGetJustify+    labelGetJustify                         ,+++-- ** labelGetLabel+    labelGetLabel                           ,+++-- ** labelGetLayout+    labelGetLayout                          ,+++-- ** labelGetLayoutOffsets+    labelGetLayoutOffsets                   ,+++-- ** labelGetLineWrap+    labelGetLineWrap                        ,+++-- ** labelGetLineWrapMode+    labelGetLineWrapMode                    ,+++-- ** labelGetLines+    labelGetLines                           ,+++-- ** labelGetMaxWidthChars+    labelGetMaxWidthChars                   ,+++-- ** labelGetMnemonicKeyval+    labelGetMnemonicKeyval                  ,+++-- ** labelGetMnemonicWidget+    labelGetMnemonicWidget                  ,+++-- ** labelGetSelectable+    labelGetSelectable                      ,+++-- ** labelGetSelectionBounds+    labelGetSelectionBounds                 ,+++-- ** labelGetSingleLineMode+    labelGetSingleLineMode                  ,+++-- ** labelGetText+    labelGetText                            ,+++-- ** labelGetTrackVisitedLinks+    labelGetTrackVisitedLinks               ,+++-- ** labelGetUseMarkup+    labelGetUseMarkup                       ,+++-- ** labelGetUseUnderline+    labelGetUseUnderline                    ,+++-- ** labelGetWidthChars+    labelGetWidthChars                      ,+++-- ** labelGetXalign+    labelGetXalign                          ,+++-- ** labelGetYalign+    labelGetYalign                          ,+++-- ** labelNew+    labelNew                                ,+++-- ** labelNewWithMnemonic+    labelNewWithMnemonic                    ,+++-- ** labelSelectRegion+    labelSelectRegion                       ,+++-- ** labelSetAngle+    labelSetAngle                           ,+++-- ** labelSetAttributes+    labelSetAttributes                      ,+++-- ** labelSetEllipsize+    labelSetEllipsize                       ,+++-- ** labelSetJustify+    labelSetJustify                         ,+++-- ** labelSetLabel+    labelSetLabel                           ,+++-- ** labelSetLineWrap+    labelSetLineWrap                        ,+++-- ** labelSetLineWrapMode+    labelSetLineWrapMode                    ,+++-- ** labelSetLines+    labelSetLines                           ,+++-- ** labelSetMarkup+    labelSetMarkup                          ,+++-- ** labelSetMarkupWithMnemonic+    labelSetMarkupWithMnemonic              ,+++-- ** labelSetMaxWidthChars+    labelSetMaxWidthChars                   ,+++-- ** labelSetMnemonicWidget+    labelSetMnemonicWidget                  ,+++-- ** labelSetPattern+    labelSetPattern                         ,+++-- ** labelSetSelectable+    labelSetSelectable                      ,+++-- ** labelSetSingleLineMode+    labelSetSingleLineMode                  ,+++-- ** labelSetText+    labelSetText                            ,+++-- ** labelSetTextWithMnemonic+    labelSetTextWithMnemonic                ,+++-- ** labelSetTrackVisitedLinks+    labelSetTrackVisitedLinks               ,+++-- ** labelSetUseMarkup+    labelSetUseMarkup                       ,+++-- ** labelSetUseUnderline+    labelSetUseUnderline                    ,+++-- ** labelSetWidthChars+    labelSetWidthChars                      ,+++-- ** labelSetXalign+    labelSetXalign                          ,+++-- ** labelSetYalign+    labelSetYalign                          ,+++++ -- * Properties+-- ** Angle+    LabelAnglePropertyInfo                  ,+    constructLabelAngle                     ,+    getLabelAngle                           ,+    setLabelAngle                           ,+++-- ** Attributes+    LabelAttributesPropertyInfo             ,+    constructLabelAttributes                ,+    getLabelAttributes                      ,+    setLabelAttributes                      ,+++-- ** CursorPosition+    LabelCursorPositionPropertyInfo         ,+    getLabelCursorPosition                  ,+++-- ** Ellipsize+    LabelEllipsizePropertyInfo              ,+    constructLabelEllipsize                 ,+    getLabelEllipsize                       ,+    setLabelEllipsize                       ,+++-- ** Justify+    LabelJustifyPropertyInfo                ,+    constructLabelJustify                   ,+    getLabelJustify                         ,+    setLabelJustify                         ,+++-- ** Label+    LabelLabelPropertyInfo                  ,+    constructLabelLabel                     ,+    getLabelLabel                           ,+    setLabelLabel                           ,+++-- ** Lines+    LabelLinesPropertyInfo                  ,+    constructLabelLines                     ,+    getLabelLines                           ,+    setLabelLines                           ,+++-- ** MaxWidthChars+    LabelMaxWidthCharsPropertyInfo          ,+    constructLabelMaxWidthChars             ,+    getLabelMaxWidthChars                   ,+    setLabelMaxWidthChars                   ,+++-- ** MnemonicKeyval+    LabelMnemonicKeyvalPropertyInfo         ,+    getLabelMnemonicKeyval                  ,+++-- ** MnemonicWidget+    LabelMnemonicWidgetPropertyInfo         ,+    constructLabelMnemonicWidget            ,+    getLabelMnemonicWidget                  ,+    setLabelMnemonicWidget                  ,+++-- ** Pattern+    LabelPatternPropertyInfo                ,+    constructLabelPattern                   ,+    setLabelPattern                         ,+++-- ** Selectable+    LabelSelectablePropertyInfo             ,+    constructLabelSelectable                ,+    getLabelSelectable                      ,+    setLabelSelectable                      ,+++-- ** SelectionBound+    LabelSelectionBoundPropertyInfo         ,+    getLabelSelectionBound                  ,+++-- ** SingleLineMode+    LabelSingleLineModePropertyInfo         ,+    constructLabelSingleLineMode            ,+    getLabelSingleLineMode                  ,+    setLabelSingleLineMode                  ,+++-- ** TrackVisitedLinks+    LabelTrackVisitedLinksPropertyInfo      ,+    constructLabelTrackVisitedLinks         ,+    getLabelTrackVisitedLinks               ,+    setLabelTrackVisitedLinks               ,+++-- ** UseMarkup+    LabelUseMarkupPropertyInfo              ,+    constructLabelUseMarkup                 ,+    getLabelUseMarkup                       ,+    setLabelUseMarkup                       ,+++-- ** UseUnderline+    LabelUseUnderlinePropertyInfo           ,+    constructLabelUseUnderline              ,+    getLabelUseUnderline                    ,+    setLabelUseUnderline                    ,+++-- ** WidthChars+    LabelWidthCharsPropertyInfo             ,+    constructLabelWidthChars                ,+    getLabelWidthChars                      ,+    setLabelWidthChars                      ,+++-- ** Wrap+    LabelWrapPropertyInfo                   ,+    constructLabelWrap                      ,+    getLabelWrap                            ,+    setLabelWrap                            ,+++-- ** WrapMode+    LabelWrapModePropertyInfo               ,+    constructLabelWrapMode                  ,+    getLabelWrapMode                        ,+    setLabelWrapMode                        ,+++-- ** Xalign+    LabelXalignPropertyInfo                 ,+    constructLabelXalign                    ,+    getLabelXalign                          ,+    setLabelXalign                          ,+++-- ** Yalign+    LabelYalignPropertyInfo                 ,+    constructLabelYalign                    ,+    getLabelYalign                          ,+    setLabelYalign                          ,+++++ -- * Signals+-- ** ActivateCurrentLink+    LabelActivateCurrentLinkCallback        ,+    LabelActivateCurrentLinkCallbackC       ,+    LabelActivateCurrentLinkSignalInfo      ,+    afterLabelActivateCurrentLink           ,+    labelActivateCurrentLinkCallbackWrapper ,+    labelActivateCurrentLinkClosure         ,+    mkLabelActivateCurrentLinkCallback      ,+    noLabelActivateCurrentLinkCallback      ,+    onLabelActivateCurrentLink              ,+++-- ** ActivateLink+    LabelActivateLinkCallback               ,+    LabelActivateLinkCallbackC              ,+    LabelActivateLinkSignalInfo             ,+    afterLabelActivateLink                  ,+    labelActivateLinkCallbackWrapper        ,+    labelActivateLinkClosure                ,+    mkLabelActivateLinkCallback             ,+    noLabelActivateLinkCallback             ,+    onLabelActivateLink                     ,+++-- ** CopyClipboard+    LabelCopyClipboardCallback              ,+    LabelCopyClipboardCallbackC             ,+    LabelCopyClipboardSignalInfo            ,+    afterLabelCopyClipboard                 ,+    labelCopyClipboardCallbackWrapper       ,+    labelCopyClipboardClosure               ,+    mkLabelCopyClipboardCallback            ,+    noLabelCopyClipboardCallback            ,+    onLabelCopyClipboard                    ,+++-- ** MoveCursor+    LabelMoveCursorCallback                 ,+    LabelMoveCursorCallbackC                ,+    LabelMoveCursorSignalInfo               ,+    afterLabelMoveCursor                    ,+    labelMoveCursorCallbackWrapper          ,+    labelMoveCursorClosure                  ,+    mkLabelMoveCursorCallback               ,+    noLabelMoveCursorCallback               ,+    onLabelMoveCursor                       ,+++-- ** PopulatePopup+    LabelPopulatePopupCallback              ,+    LabelPopulatePopupCallbackC             ,+    LabelPopulatePopupSignalInfo            ,+    afterLabelPopulatePopup                 ,+    labelPopulatePopupCallbackWrapper       ,+    labelPopulatePopupClosure               ,+    mkLabelPopulatePopupCallback            ,+    noLabelPopulatePopupCallback            ,+    onLabelPopulatePopup                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango++newtype Label = Label (ForeignPtr Label)+foreign import ccall "gtk_label_get_type"+    c_gtk_label_get_type :: IO GType++type instance ParentTypes Label = LabelParentTypes+type LabelParentTypes = '[Misc, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Label where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_label_get_type+    ++class GObject o => LabelK o+instance (GObject o, IsDescendantOf Label o) => LabelK o++toLabel :: LabelK o => o -> IO Label+toLabel = unsafeCastTo Label++noLabel :: Maybe Label+noLabel = Nothing++-- signal Label::activate-current-link+type LabelActivateCurrentLinkCallback =+    IO ()++noLabelActivateCurrentLinkCallback :: Maybe LabelActivateCurrentLinkCallback+noLabelActivateCurrentLinkCallback = Nothing++type LabelActivateCurrentLinkCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkLabelActivateCurrentLinkCallback :: LabelActivateCurrentLinkCallbackC -> IO (FunPtr LabelActivateCurrentLinkCallbackC)++labelActivateCurrentLinkClosure :: LabelActivateCurrentLinkCallback -> IO Closure+labelActivateCurrentLinkClosure cb = newCClosure =<< mkLabelActivateCurrentLinkCallback wrapped+    where wrapped = labelActivateCurrentLinkCallbackWrapper cb++labelActivateCurrentLinkCallbackWrapper ::+    LabelActivateCurrentLinkCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+labelActivateCurrentLinkCallbackWrapper _cb _ _ = do+    _cb ++onLabelActivateCurrentLink :: (GObject a, MonadIO m) => a -> LabelActivateCurrentLinkCallback -> m SignalHandlerId+onLabelActivateCurrentLink obj cb = liftIO $ connectLabelActivateCurrentLink obj cb SignalConnectBefore+afterLabelActivateCurrentLink :: (GObject a, MonadIO m) => a -> LabelActivateCurrentLinkCallback -> m SignalHandlerId+afterLabelActivateCurrentLink obj cb = connectLabelActivateCurrentLink obj cb SignalConnectAfter++connectLabelActivateCurrentLink :: (GObject a, MonadIO m) =>+                                   a -> LabelActivateCurrentLinkCallback -> SignalConnectMode -> m SignalHandlerId+connectLabelActivateCurrentLink obj cb after = liftIO $ do+    cb' <- mkLabelActivateCurrentLinkCallback (labelActivateCurrentLinkCallbackWrapper cb)+    connectSignalFunPtr obj "activate-current-link" cb' after++-- signal Label::activate-link+type LabelActivateLinkCallback =+    T.Text ->+    IO Bool++noLabelActivateLinkCallback :: Maybe LabelActivateLinkCallback+noLabelActivateLinkCallback = Nothing++type LabelActivateLinkCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkLabelActivateLinkCallback :: LabelActivateLinkCallbackC -> IO (FunPtr LabelActivateLinkCallbackC)++labelActivateLinkClosure :: LabelActivateLinkCallback -> IO Closure+labelActivateLinkClosure cb = newCClosure =<< mkLabelActivateLinkCallback wrapped+    where wrapped = labelActivateLinkCallbackWrapper cb++labelActivateLinkCallbackWrapper ::+    LabelActivateLinkCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO CInt+labelActivateLinkCallbackWrapper _cb _ uri _ = do+    uri' <- cstringToText uri+    result <- _cb  uri'+    let result' = (fromIntegral . fromEnum) result+    return result'++onLabelActivateLink :: (GObject a, MonadIO m) => a -> LabelActivateLinkCallback -> m SignalHandlerId+onLabelActivateLink obj cb = liftIO $ connectLabelActivateLink obj cb SignalConnectBefore+afterLabelActivateLink :: (GObject a, MonadIO m) => a -> LabelActivateLinkCallback -> m SignalHandlerId+afterLabelActivateLink obj cb = connectLabelActivateLink obj cb SignalConnectAfter++connectLabelActivateLink :: (GObject a, MonadIO m) =>+                            a -> LabelActivateLinkCallback -> SignalConnectMode -> m SignalHandlerId+connectLabelActivateLink obj cb after = liftIO $ do+    cb' <- mkLabelActivateLinkCallback (labelActivateLinkCallbackWrapper cb)+    connectSignalFunPtr obj "activate-link" cb' after++-- signal Label::copy-clipboard+type LabelCopyClipboardCallback =+    IO ()++noLabelCopyClipboardCallback :: Maybe LabelCopyClipboardCallback+noLabelCopyClipboardCallback = Nothing++type LabelCopyClipboardCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkLabelCopyClipboardCallback :: LabelCopyClipboardCallbackC -> IO (FunPtr LabelCopyClipboardCallbackC)++labelCopyClipboardClosure :: LabelCopyClipboardCallback -> IO Closure+labelCopyClipboardClosure cb = newCClosure =<< mkLabelCopyClipboardCallback wrapped+    where wrapped = labelCopyClipboardCallbackWrapper cb++labelCopyClipboardCallbackWrapper ::+    LabelCopyClipboardCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+labelCopyClipboardCallbackWrapper _cb _ _ = do+    _cb ++onLabelCopyClipboard :: (GObject a, MonadIO m) => a -> LabelCopyClipboardCallback -> m SignalHandlerId+onLabelCopyClipboard obj cb = liftIO $ connectLabelCopyClipboard obj cb SignalConnectBefore+afterLabelCopyClipboard :: (GObject a, MonadIO m) => a -> LabelCopyClipboardCallback -> m SignalHandlerId+afterLabelCopyClipboard obj cb = connectLabelCopyClipboard obj cb SignalConnectAfter++connectLabelCopyClipboard :: (GObject a, MonadIO m) =>+                             a -> LabelCopyClipboardCallback -> SignalConnectMode -> m SignalHandlerId+connectLabelCopyClipboard obj cb after = liftIO $ do+    cb' <- mkLabelCopyClipboardCallback (labelCopyClipboardCallbackWrapper cb)+    connectSignalFunPtr obj "copy-clipboard" cb' after++-- signal Label::move-cursor+type LabelMoveCursorCallback =+    MovementStep ->+    Int32 ->+    Bool ->+    IO ()++noLabelMoveCursorCallback :: Maybe LabelMoveCursorCallback+noLabelMoveCursorCallback = Nothing++type LabelMoveCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkLabelMoveCursorCallback :: LabelMoveCursorCallbackC -> IO (FunPtr LabelMoveCursorCallbackC)++labelMoveCursorClosure :: LabelMoveCursorCallback -> IO Closure+labelMoveCursorClosure cb = newCClosure =<< mkLabelMoveCursorCallback wrapped+    where wrapped = labelMoveCursorCallbackWrapper cb++labelMoveCursorCallbackWrapper ::+    LabelMoveCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    CInt ->+    Ptr () ->+    IO ()+labelMoveCursorCallbackWrapper _cb _ step count extend_selection _ = do+    let step' = (toEnum . fromIntegral) step+    let extend_selection' = (/= 0) extend_selection+    _cb  step' count extend_selection'++onLabelMoveCursor :: (GObject a, MonadIO m) => a -> LabelMoveCursorCallback -> m SignalHandlerId+onLabelMoveCursor obj cb = liftIO $ connectLabelMoveCursor obj cb SignalConnectBefore+afterLabelMoveCursor :: (GObject a, MonadIO m) => a -> LabelMoveCursorCallback -> m SignalHandlerId+afterLabelMoveCursor obj cb = connectLabelMoveCursor obj cb SignalConnectAfter++connectLabelMoveCursor :: (GObject a, MonadIO m) =>+                          a -> LabelMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectLabelMoveCursor obj cb after = liftIO $ do+    cb' <- mkLabelMoveCursorCallback (labelMoveCursorCallbackWrapper cb)+    connectSignalFunPtr obj "move-cursor" cb' after++-- signal Label::populate-popup+type LabelPopulatePopupCallback =+    Menu ->+    IO ()++noLabelPopulatePopupCallback :: Maybe LabelPopulatePopupCallback+noLabelPopulatePopupCallback = Nothing++type LabelPopulatePopupCallbackC =+    Ptr () ->                               -- object+    Ptr Menu ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkLabelPopulatePopupCallback :: LabelPopulatePopupCallbackC -> IO (FunPtr LabelPopulatePopupCallbackC)++labelPopulatePopupClosure :: LabelPopulatePopupCallback -> IO Closure+labelPopulatePopupClosure cb = newCClosure =<< mkLabelPopulatePopupCallback wrapped+    where wrapped = labelPopulatePopupCallbackWrapper cb++labelPopulatePopupCallbackWrapper ::+    LabelPopulatePopupCallback ->+    Ptr () ->+    Ptr Menu ->+    Ptr () ->+    IO ()+labelPopulatePopupCallbackWrapper _cb _ menu _ = do+    menu' <- (newObject Menu) menu+    _cb  menu'++onLabelPopulatePopup :: (GObject a, MonadIO m) => a -> LabelPopulatePopupCallback -> m SignalHandlerId+onLabelPopulatePopup obj cb = liftIO $ connectLabelPopulatePopup obj cb SignalConnectBefore+afterLabelPopulatePopup :: (GObject a, MonadIO m) => a -> LabelPopulatePopupCallback -> m SignalHandlerId+afterLabelPopulatePopup obj cb = connectLabelPopulatePopup obj cb SignalConnectAfter++connectLabelPopulatePopup :: (GObject a, MonadIO m) =>+                             a -> LabelPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId+connectLabelPopulatePopup obj cb after = liftIO $ do+    cb' <- mkLabelPopulatePopupCallback (labelPopulatePopupCallbackWrapper cb)+    connectSignalFunPtr obj "populate-popup" cb' after++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_halign() instead. If you are using\n  #GtkLabel, use #GtkLabel:xalign instead."})}+--- XXX Duplicated object with different types:+  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_valign() instead. If you are using\n  #GtkLabel, use #GtkLabel:yalign instead."})}+-- VVV Prop "angle"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelAngle :: (MonadIO m, LabelK o) => o -> m Double+getLabelAngle obj = liftIO $ getObjectPropertyDouble obj "angle"++setLabelAngle :: (MonadIO m, LabelK o) => o -> Double -> m ()+setLabelAngle obj val = liftIO $ setObjectPropertyDouble obj "angle" val++constructLabelAngle :: Double -> IO ([Char], GValue)+constructLabelAngle val = constructObjectPropertyDouble "angle" val++data LabelAnglePropertyInfo+instance AttrInfo LabelAnglePropertyInfo where+    type AttrAllowedOps LabelAnglePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelAnglePropertyInfo = (~) Double+    type AttrBaseTypeConstraint LabelAnglePropertyInfo = LabelK+    type AttrGetType LabelAnglePropertyInfo = Double+    type AttrLabel LabelAnglePropertyInfo = "Label::angle"+    attrGet _ = getLabelAngle+    attrSet _ = setLabelAngle+    attrConstruct _ = constructLabelAngle++-- VVV Prop "attributes"+   -- Type: TInterface "Pango" "AttrList"+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelAttributes :: (MonadIO m, LabelK o) => o -> m Pango.AttrList+getLabelAttributes obj = liftIO $ getObjectPropertyBoxed obj "attributes" Pango.AttrList++setLabelAttributes :: (MonadIO m, LabelK o) => o -> Pango.AttrList -> m ()+setLabelAttributes obj val = liftIO $ setObjectPropertyBoxed obj "attributes" val++constructLabelAttributes :: Pango.AttrList -> IO ([Char], GValue)+constructLabelAttributes val = constructObjectPropertyBoxed "attributes" val++data LabelAttributesPropertyInfo+instance AttrInfo LabelAttributesPropertyInfo where+    type AttrAllowedOps LabelAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelAttributesPropertyInfo = (~) Pango.AttrList+    type AttrBaseTypeConstraint LabelAttributesPropertyInfo = LabelK+    type AttrGetType LabelAttributesPropertyInfo = Pango.AttrList+    type AttrLabel LabelAttributesPropertyInfo = "Label::attributes"+    attrGet _ = getLabelAttributes+    attrSet _ = setLabelAttributes+    attrConstruct _ = constructLabelAttributes++-- VVV Prop "cursor-position"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getLabelCursorPosition :: (MonadIO m, LabelK o) => o -> m Int32+getLabelCursorPosition obj = liftIO $ getObjectPropertyCInt obj "cursor-position"++data LabelCursorPositionPropertyInfo+instance AttrInfo LabelCursorPositionPropertyInfo where+    type AttrAllowedOps LabelCursorPositionPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LabelCursorPositionPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LabelCursorPositionPropertyInfo = LabelK+    type AttrGetType LabelCursorPositionPropertyInfo = Int32+    type AttrLabel LabelCursorPositionPropertyInfo = "Label::cursor-position"+    attrGet _ = getLabelCursorPosition+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "ellipsize"+   -- Type: TInterface "Pango" "EllipsizeMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelEllipsize :: (MonadIO m, LabelK o) => o -> m Pango.EllipsizeMode+getLabelEllipsize obj = liftIO $ getObjectPropertyEnum obj "ellipsize"++setLabelEllipsize :: (MonadIO m, LabelK o) => o -> Pango.EllipsizeMode -> m ()+setLabelEllipsize obj val = liftIO $ setObjectPropertyEnum obj "ellipsize" val++constructLabelEllipsize :: Pango.EllipsizeMode -> IO ([Char], GValue)+constructLabelEllipsize val = constructObjectPropertyEnum "ellipsize" val++data LabelEllipsizePropertyInfo+instance AttrInfo LabelEllipsizePropertyInfo where+    type AttrAllowedOps LabelEllipsizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelEllipsizePropertyInfo = (~) Pango.EllipsizeMode+    type AttrBaseTypeConstraint LabelEllipsizePropertyInfo = LabelK+    type AttrGetType LabelEllipsizePropertyInfo = Pango.EllipsizeMode+    type AttrLabel LabelEllipsizePropertyInfo = "Label::ellipsize"+    attrGet _ = getLabelEllipsize+    attrSet _ = setLabelEllipsize+    attrConstruct _ = constructLabelEllipsize++-- VVV Prop "justify"+   -- Type: TInterface "Gtk" "Justification"+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelJustify :: (MonadIO m, LabelK o) => o -> m Justification+getLabelJustify obj = liftIO $ getObjectPropertyEnum obj "justify"++setLabelJustify :: (MonadIO m, LabelK o) => o -> Justification -> m ()+setLabelJustify obj val = liftIO $ setObjectPropertyEnum obj "justify" val++constructLabelJustify :: Justification -> IO ([Char], GValue)+constructLabelJustify val = constructObjectPropertyEnum "justify" val++data LabelJustifyPropertyInfo+instance AttrInfo LabelJustifyPropertyInfo where+    type AttrAllowedOps LabelJustifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelJustifyPropertyInfo = (~) Justification+    type AttrBaseTypeConstraint LabelJustifyPropertyInfo = LabelK+    type AttrGetType LabelJustifyPropertyInfo = Justification+    type AttrLabel LabelJustifyPropertyInfo = "Label::justify"+    attrGet _ = getLabelJustify+    attrSet _ = setLabelJustify+    attrConstruct _ = constructLabelJustify++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelLabel :: (MonadIO m, LabelK o) => o -> m T.Text+getLabelLabel obj = liftIO $ getObjectPropertyString obj "label"++setLabelLabel :: (MonadIO m, LabelK o) => o -> T.Text -> m ()+setLabelLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructLabelLabel :: T.Text -> IO ([Char], GValue)+constructLabelLabel val = constructObjectPropertyString "label" val++data LabelLabelPropertyInfo+instance AttrInfo LabelLabelPropertyInfo where+    type AttrAllowedOps LabelLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LabelLabelPropertyInfo = LabelK+    type AttrGetType LabelLabelPropertyInfo = T.Text+    type AttrLabel LabelLabelPropertyInfo = "Label::label"+    attrGet _ = getLabelLabel+    attrSet _ = setLabelLabel+    attrConstruct _ = constructLabelLabel++-- VVV Prop "lines"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelLines :: (MonadIO m, LabelK o) => o -> m Int32+getLabelLines obj = liftIO $ getObjectPropertyCInt obj "lines"++setLabelLines :: (MonadIO m, LabelK o) => o -> Int32 -> m ()+setLabelLines obj val = liftIO $ setObjectPropertyCInt obj "lines" val++constructLabelLines :: Int32 -> IO ([Char], GValue)+constructLabelLines val = constructObjectPropertyCInt "lines" val++data LabelLinesPropertyInfo+instance AttrInfo LabelLinesPropertyInfo where+    type AttrAllowedOps LabelLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelLinesPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint LabelLinesPropertyInfo = LabelK+    type AttrGetType LabelLinesPropertyInfo = Int32+    type AttrLabel LabelLinesPropertyInfo = "Label::lines"+    attrGet _ = getLabelLines+    attrSet _ = setLabelLines+    attrConstruct _ = constructLabelLines++-- VVV Prop "max-width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelMaxWidthChars :: (MonadIO m, LabelK o) => o -> m Int32+getLabelMaxWidthChars obj = liftIO $ getObjectPropertyCInt obj "max-width-chars"++setLabelMaxWidthChars :: (MonadIO m, LabelK o) => o -> Int32 -> m ()+setLabelMaxWidthChars obj val = liftIO $ setObjectPropertyCInt obj "max-width-chars" val++constructLabelMaxWidthChars :: Int32 -> IO ([Char], GValue)+constructLabelMaxWidthChars val = constructObjectPropertyCInt "max-width-chars" val++data LabelMaxWidthCharsPropertyInfo+instance AttrInfo LabelMaxWidthCharsPropertyInfo where+    type AttrAllowedOps LabelMaxWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelMaxWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint LabelMaxWidthCharsPropertyInfo = LabelK+    type AttrGetType LabelMaxWidthCharsPropertyInfo = Int32+    type AttrLabel LabelMaxWidthCharsPropertyInfo = "Label::max-width-chars"+    attrGet _ = getLabelMaxWidthChars+    attrSet _ = setLabelMaxWidthChars+    attrConstruct _ = constructLabelMaxWidthChars++-- VVV Prop "mnemonic-keyval"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable]++getLabelMnemonicKeyval :: (MonadIO m, LabelK o) => o -> m Word32+getLabelMnemonicKeyval obj = liftIO $ getObjectPropertyCUInt obj "mnemonic-keyval"++data LabelMnemonicKeyvalPropertyInfo+instance AttrInfo LabelMnemonicKeyvalPropertyInfo where+    type AttrAllowedOps LabelMnemonicKeyvalPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LabelMnemonicKeyvalPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LabelMnemonicKeyvalPropertyInfo = LabelK+    type AttrGetType LabelMnemonicKeyvalPropertyInfo = Word32+    type AttrLabel LabelMnemonicKeyvalPropertyInfo = "Label::mnemonic-keyval"+    attrGet _ = getLabelMnemonicKeyval+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "mnemonic-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelMnemonicWidget :: (MonadIO m, LabelK o) => o -> m Widget+getLabelMnemonicWidget obj = liftIO $ getObjectPropertyObject obj "mnemonic-widget" Widget++setLabelMnemonicWidget :: (MonadIO m, LabelK o, WidgetK a) => o -> a -> m ()+setLabelMnemonicWidget obj val = liftIO $ setObjectPropertyObject obj "mnemonic-widget" val++constructLabelMnemonicWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructLabelMnemonicWidget val = constructObjectPropertyObject "mnemonic-widget" val++data LabelMnemonicWidgetPropertyInfo+instance AttrInfo LabelMnemonicWidgetPropertyInfo where+    type AttrAllowedOps LabelMnemonicWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelMnemonicWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint LabelMnemonicWidgetPropertyInfo = LabelK+    type AttrGetType LabelMnemonicWidgetPropertyInfo = Widget+    type AttrLabel LabelMnemonicWidgetPropertyInfo = "Label::mnemonic-widget"+    attrGet _ = getLabelMnemonicWidget+    attrSet _ = setLabelMnemonicWidget+    attrConstruct _ = constructLabelMnemonicWidget++-- VVV Prop "pattern"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyWritable]++setLabelPattern :: (MonadIO m, LabelK o) => o -> T.Text -> m ()+setLabelPattern obj val = liftIO $ setObjectPropertyString obj "pattern" val++constructLabelPattern :: T.Text -> IO ([Char], GValue)+constructLabelPattern val = constructObjectPropertyString "pattern" val++data LabelPatternPropertyInfo+instance AttrInfo LabelPatternPropertyInfo where+    type AttrAllowedOps LabelPatternPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint LabelPatternPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LabelPatternPropertyInfo = LabelK+    type AttrGetType LabelPatternPropertyInfo = ()+    type AttrLabel LabelPatternPropertyInfo = "Label::pattern"+    attrGet _ = undefined+    attrSet _ = setLabelPattern+    attrConstruct _ = constructLabelPattern++-- VVV Prop "selectable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelSelectable :: (MonadIO m, LabelK o) => o -> m Bool+getLabelSelectable obj = liftIO $ getObjectPropertyBool obj "selectable"++setLabelSelectable :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelSelectable obj val = liftIO $ setObjectPropertyBool obj "selectable" val++constructLabelSelectable :: Bool -> IO ([Char], GValue)+constructLabelSelectable val = constructObjectPropertyBool "selectable" val++data LabelSelectablePropertyInfo+instance AttrInfo LabelSelectablePropertyInfo where+    type AttrAllowedOps LabelSelectablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelSelectablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelSelectablePropertyInfo = LabelK+    type AttrGetType LabelSelectablePropertyInfo = Bool+    type AttrLabel LabelSelectablePropertyInfo = "Label::selectable"+    attrGet _ = getLabelSelectable+    attrSet _ = setLabelSelectable+    attrConstruct _ = constructLabelSelectable++-- VVV Prop "selection-bound"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getLabelSelectionBound :: (MonadIO m, LabelK o) => o -> m Int32+getLabelSelectionBound obj = liftIO $ getObjectPropertyCInt obj "selection-bound"++data LabelSelectionBoundPropertyInfo+instance AttrInfo LabelSelectionBoundPropertyInfo where+    type AttrAllowedOps LabelSelectionBoundPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint LabelSelectionBoundPropertyInfo = (~) ()+    type AttrBaseTypeConstraint LabelSelectionBoundPropertyInfo = LabelK+    type AttrGetType LabelSelectionBoundPropertyInfo = Int32+    type AttrLabel LabelSelectionBoundPropertyInfo = "Label::selection-bound"+    attrGet _ = getLabelSelectionBound+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "single-line-mode"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelSingleLineMode :: (MonadIO m, LabelK o) => o -> m Bool+getLabelSingleLineMode obj = liftIO $ getObjectPropertyBool obj "single-line-mode"++setLabelSingleLineMode :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelSingleLineMode obj val = liftIO $ setObjectPropertyBool obj "single-line-mode" val++constructLabelSingleLineMode :: Bool -> IO ([Char], GValue)+constructLabelSingleLineMode val = constructObjectPropertyBool "single-line-mode" val++data LabelSingleLineModePropertyInfo+instance AttrInfo LabelSingleLineModePropertyInfo where+    type AttrAllowedOps LabelSingleLineModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelSingleLineModePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelSingleLineModePropertyInfo = LabelK+    type AttrGetType LabelSingleLineModePropertyInfo = Bool+    type AttrLabel LabelSingleLineModePropertyInfo = "Label::single-line-mode"+    attrGet _ = getLabelSingleLineMode+    attrSet _ = setLabelSingleLineMode+    attrConstruct _ = constructLabelSingleLineMode++-- VVV Prop "track-visited-links"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelTrackVisitedLinks :: (MonadIO m, LabelK o) => o -> m Bool+getLabelTrackVisitedLinks obj = liftIO $ getObjectPropertyBool obj "track-visited-links"++setLabelTrackVisitedLinks :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelTrackVisitedLinks obj val = liftIO $ setObjectPropertyBool obj "track-visited-links" val++constructLabelTrackVisitedLinks :: Bool -> IO ([Char], GValue)+constructLabelTrackVisitedLinks val = constructObjectPropertyBool "track-visited-links" val++data LabelTrackVisitedLinksPropertyInfo+instance AttrInfo LabelTrackVisitedLinksPropertyInfo where+    type AttrAllowedOps LabelTrackVisitedLinksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelTrackVisitedLinksPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelTrackVisitedLinksPropertyInfo = LabelK+    type AttrGetType LabelTrackVisitedLinksPropertyInfo = Bool+    type AttrLabel LabelTrackVisitedLinksPropertyInfo = "Label::track-visited-links"+    attrGet _ = getLabelTrackVisitedLinks+    attrSet _ = setLabelTrackVisitedLinks+    attrConstruct _ = constructLabelTrackVisitedLinks++-- VVV Prop "use-markup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelUseMarkup :: (MonadIO m, LabelK o) => o -> m Bool+getLabelUseMarkup obj = liftIO $ getObjectPropertyBool obj "use-markup"++setLabelUseMarkup :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelUseMarkup obj val = liftIO $ setObjectPropertyBool obj "use-markup" val++constructLabelUseMarkup :: Bool -> IO ([Char], GValue)+constructLabelUseMarkup val = constructObjectPropertyBool "use-markup" val++data LabelUseMarkupPropertyInfo+instance AttrInfo LabelUseMarkupPropertyInfo where+    type AttrAllowedOps LabelUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelUseMarkupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelUseMarkupPropertyInfo = LabelK+    type AttrGetType LabelUseMarkupPropertyInfo = Bool+    type AttrLabel LabelUseMarkupPropertyInfo = "Label::use-markup"+    attrGet _ = getLabelUseMarkup+    attrSet _ = setLabelUseMarkup+    attrConstruct _ = constructLabelUseMarkup++-- VVV Prop "use-underline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelUseUnderline :: (MonadIO m, LabelK o) => o -> m Bool+getLabelUseUnderline obj = liftIO $ getObjectPropertyBool obj "use-underline"++setLabelUseUnderline :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelUseUnderline obj val = liftIO $ setObjectPropertyBool obj "use-underline" val++constructLabelUseUnderline :: Bool -> IO ([Char], GValue)+constructLabelUseUnderline val = constructObjectPropertyBool "use-underline" val++data LabelUseUnderlinePropertyInfo+instance AttrInfo LabelUseUnderlinePropertyInfo where+    type AttrAllowedOps LabelUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelUseUnderlinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelUseUnderlinePropertyInfo = LabelK+    type AttrGetType LabelUseUnderlinePropertyInfo = Bool+    type AttrLabel LabelUseUnderlinePropertyInfo = "Label::use-underline"+    attrGet _ = getLabelUseUnderline+    attrSet _ = setLabelUseUnderline+    attrConstruct _ = constructLabelUseUnderline++-- VVV Prop "width-chars"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelWidthChars :: (MonadIO m, LabelK o) => o -> m Int32+getLabelWidthChars obj = liftIO $ getObjectPropertyCInt obj "width-chars"++setLabelWidthChars :: (MonadIO m, LabelK o) => o -> Int32 -> m ()+setLabelWidthChars obj val = liftIO $ setObjectPropertyCInt obj "width-chars" val++constructLabelWidthChars :: Int32 -> IO ([Char], GValue)+constructLabelWidthChars val = constructObjectPropertyCInt "width-chars" val++data LabelWidthCharsPropertyInfo+instance AttrInfo LabelWidthCharsPropertyInfo where+    type AttrAllowedOps LabelWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelWidthCharsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint LabelWidthCharsPropertyInfo = LabelK+    type AttrGetType LabelWidthCharsPropertyInfo = Int32+    type AttrLabel LabelWidthCharsPropertyInfo = "Label::width-chars"+    attrGet _ = getLabelWidthChars+    attrSet _ = setLabelWidthChars+    attrConstruct _ = constructLabelWidthChars++-- VVV Prop "wrap"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelWrap :: (MonadIO m, LabelK o) => o -> m Bool+getLabelWrap obj = liftIO $ getObjectPropertyBool obj "wrap"++setLabelWrap :: (MonadIO m, LabelK o) => o -> Bool -> m ()+setLabelWrap obj val = liftIO $ setObjectPropertyBool obj "wrap" val++constructLabelWrap :: Bool -> IO ([Char], GValue)+constructLabelWrap val = constructObjectPropertyBool "wrap" val++data LabelWrapPropertyInfo+instance AttrInfo LabelWrapPropertyInfo where+    type AttrAllowedOps LabelWrapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelWrapPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LabelWrapPropertyInfo = LabelK+    type AttrGetType LabelWrapPropertyInfo = Bool+    type AttrLabel LabelWrapPropertyInfo = "Label::wrap"+    attrGet _ = getLabelWrap+    attrSet _ = setLabelWrap+    attrConstruct _ = constructLabelWrap++-- VVV Prop "wrap-mode"+   -- Type: TInterface "Pango" "WrapMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelWrapMode :: (MonadIO m, LabelK o) => o -> m Pango.WrapMode+getLabelWrapMode obj = liftIO $ getObjectPropertyEnum obj "wrap-mode"++setLabelWrapMode :: (MonadIO m, LabelK o) => o -> Pango.WrapMode -> m ()+setLabelWrapMode obj val = liftIO $ setObjectPropertyEnum obj "wrap-mode" val++constructLabelWrapMode :: Pango.WrapMode -> IO ([Char], GValue)+constructLabelWrapMode val = constructObjectPropertyEnum "wrap-mode" val++data LabelWrapModePropertyInfo+instance AttrInfo LabelWrapModePropertyInfo where+    type AttrAllowedOps LabelWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelWrapModePropertyInfo = (~) Pango.WrapMode+    type AttrBaseTypeConstraint LabelWrapModePropertyInfo = LabelK+    type AttrGetType LabelWrapModePropertyInfo = Pango.WrapMode+    type AttrLabel LabelWrapModePropertyInfo = "Label::wrap-mode"+    attrGet _ = getLabelWrapMode+    attrSet _ = setLabelWrapMode+    attrConstruct _ = constructLabelWrapMode++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelXalign :: (MonadIO m, LabelK o) => o -> m Float+getLabelXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setLabelXalign :: (MonadIO m, LabelK o) => o -> Float -> m ()+setLabelXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructLabelXalign :: Float -> IO ([Char], GValue)+constructLabelXalign val = constructObjectPropertyFloat "xalign" val++data LabelXalignPropertyInfo+instance AttrInfo LabelXalignPropertyInfo where+    type AttrAllowedOps LabelXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint LabelXalignPropertyInfo = LabelK+    type AttrGetType LabelXalignPropertyInfo = Float+    type AttrLabel LabelXalignPropertyInfo = "Label::xalign"+    attrGet _ = getLabelXalign+    attrSet _ = setLabelXalign+    attrConstruct _ = constructLabelXalign++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getLabelYalign :: (MonadIO m, LabelK o) => o -> m Float+getLabelYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setLabelYalign :: (MonadIO m, LabelK o) => o -> Float -> m ()+setLabelYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructLabelYalign :: Float -> IO ([Char], GValue)+constructLabelYalign val = constructObjectPropertyFloat "yalign" val++data LabelYalignPropertyInfo+instance AttrInfo LabelYalignPropertyInfo where+    type AttrAllowedOps LabelYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LabelYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint LabelYalignPropertyInfo = LabelK+    type AttrGetType LabelYalignPropertyInfo = Float+    type AttrLabel LabelYalignPropertyInfo = "Label::yalign"+    attrGet _ = getLabelYalign+    attrSet _ = setLabelYalign+    attrConstruct _ = constructLabelYalign++type instance AttributeList Label = LabelAttributeList+type LabelAttributeList = ('[ '("angle", LabelAnglePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("attributes", LabelAttributesPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("cursor-position", LabelCursorPositionPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("ellipsize", LabelEllipsizePropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("justify", LabelJustifyPropertyInfo), '("label", LabelLabelPropertyInfo), '("lines", LabelLinesPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-width-chars", LabelMaxWidthCharsPropertyInfo), '("mnemonic-keyval", LabelMnemonicKeyvalPropertyInfo), '("mnemonic-widget", LabelMnemonicWidgetPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pattern", LabelPatternPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selectable", LabelSelectablePropertyInfo), '("selection-bound", LabelSelectionBoundPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("single-line-mode", LabelSingleLineModePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("track-visited-links", LabelTrackVisitedLinksPropertyInfo), '("use-markup", LabelUseMarkupPropertyInfo), '("use-underline", LabelUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-chars", LabelWidthCharsPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("wrap", LabelWrapPropertyInfo), '("wrap-mode", LabelWrapModePropertyInfo), '("xpad", MiscXpadPropertyInfo), '("ypad", MiscYpadPropertyInfo)] :: [(Symbol, *)])++data LabelActivateCurrentLinkSignalInfo+instance SignalInfo LabelActivateCurrentLinkSignalInfo where+    type HaskellCallbackType LabelActivateCurrentLinkSignalInfo = LabelActivateCurrentLinkCallback+    connectSignal _ = connectLabelActivateCurrentLink++data LabelActivateLinkSignalInfo+instance SignalInfo LabelActivateLinkSignalInfo where+    type HaskellCallbackType LabelActivateLinkSignalInfo = LabelActivateLinkCallback+    connectSignal _ = connectLabelActivateLink++data LabelCopyClipboardSignalInfo+instance SignalInfo LabelCopyClipboardSignalInfo where+    type HaskellCallbackType LabelCopyClipboardSignalInfo = LabelCopyClipboardCallback+    connectSignal _ = connectLabelCopyClipboard++data LabelMoveCursorSignalInfo+instance SignalInfo LabelMoveCursorSignalInfo where+    type HaskellCallbackType LabelMoveCursorSignalInfo = LabelMoveCursorCallback+    connectSignal _ = connectLabelMoveCursor++data LabelPopulatePopupSignalInfo+instance SignalInfo LabelPopulatePopupSignalInfo where+    type HaskellCallbackType LabelPopulatePopupSignalInfo = LabelPopulatePopupCallback+    connectSignal _ = connectLabelPopulatePopup++type instance SignalList Label = LabelSignalList+type LabelSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-current-link", LabelActivateCurrentLinkSignalInfo), '("activate-link", LabelActivateLinkSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("copy-clipboard", LabelCopyClipboardSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", LabelMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("populate-popup", LabelPopulatePopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Label::new+-- method type : Constructor+-- Args : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Label"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_new" gtk_label_new :: +    CString ->                              -- str : TBasicType TUTF8+    IO (Ptr Label)+++labelNew ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- str+    m Label+labelNew str = liftIO $ do+    maybeStr <- case str of+        Nothing -> return nullPtr+        Just jStr -> do+            jStr' <- textToCString jStr+            return jStr'+    result <- gtk_label_new maybeStr+    checkUnexpectedReturnNULL "gtk_label_new" result+    result' <- (newObject Label) result+    freeMem maybeStr+    return result'++-- method Label::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Label"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_new_with_mnemonic" gtk_label_new_with_mnemonic :: +    CString ->                              -- str : TBasicType TUTF8+    IO (Ptr Label)+++labelNewWithMnemonic ::+    (MonadIO m) =>+    Maybe (T.Text) ->                       -- str+    m Label+labelNewWithMnemonic str = liftIO $ do+    maybeStr <- case str of+        Nothing -> return nullPtr+        Just jStr -> do+            jStr' <- textToCString jStr+            return jStr'+    result <- gtk_label_new_with_mnemonic maybeStr+    checkUnexpectedReturnNULL "gtk_label_new_with_mnemonic" result+    result' <- (newObject Label) result+    freeMem maybeStr+    return result'++-- method Label::get_angle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_angle" gtk_label_get_angle :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CDouble+++labelGetAngle ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Double+labelGetAngle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_angle _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Label::get_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "AttrList"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_attributes" gtk_label_get_attributes :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO (Ptr Pango.AttrList)+++labelGetAttributes ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Pango.AttrList+labelGetAttributes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_attributes _obj'+    checkUnexpectedReturnNULL "gtk_label_get_attributes" result+    result' <- (newBoxed Pango.AttrList) result+    touchManagedPtr _obj+    return result'++-- method Label::get_current_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_current_uri" gtk_label_get_current_uri :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CString+++labelGetCurrentUri ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m T.Text+labelGetCurrentUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_current_uri _obj'+    checkUnexpectedReturnNULL "gtk_label_get_current_uri" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Label::get_ellipsize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "EllipsizeMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_ellipsize" gtk_label_get_ellipsize :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CUInt+++labelGetEllipsize ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Pango.EllipsizeMode+labelGetEllipsize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_ellipsize _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Label::get_justify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Justification"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_justify" gtk_label_get_justify :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CUInt+++labelGetJustify ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Justification+labelGetJustify _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_justify _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Label::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_label" gtk_label_get_label :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CString+++labelGetLabel ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m T.Text+labelGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_label _obj'+    checkUnexpectedReturnNULL "gtk_label_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Label::get_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "Layout"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_layout" gtk_label_get_layout :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO (Ptr Pango.Layout)+++labelGetLayout ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Pango.Layout+labelGetLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_layout _obj'+    checkUnexpectedReturnNULL "gtk_label_get_layout" result+    result' <- (newObject Pango.Layout) result+    touchManagedPtr _obj+    return result'++-- method Label::get_layout_offsets+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_layout_offsets" gtk_label_get_layout_offsets :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Ptr Int32 ->                            -- x : TBasicType TInt32+    Ptr Int32 ->                            -- y : TBasicType TInt32+    IO ()+++labelGetLayoutOffsets ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+labelGetLayoutOffsets _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    x <- allocMem :: IO (Ptr Int32)+    y <- allocMem :: IO (Ptr Int32)+    gtk_label_get_layout_offsets _obj' x y+    x' <- peek x+    y' <- peek y+    touchManagedPtr _obj+    freeMem x+    freeMem y+    return (x', y')++-- method Label::get_line_wrap+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_line_wrap" gtk_label_get_line_wrap :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetLineWrap ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetLineWrap _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_line_wrap _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_line_wrap_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "WrapMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_line_wrap_mode" gtk_label_get_line_wrap_mode :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CUInt+++labelGetLineWrapMode ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Pango.WrapMode+labelGetLineWrapMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_line_wrap_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Label::get_lines+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_lines" gtk_label_get_lines :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO Int32+++labelGetLines ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Int32+labelGetLines _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_lines _obj'+    touchManagedPtr _obj+    return result++-- method Label::get_max_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_max_width_chars" gtk_label_get_max_width_chars :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO Int32+++labelGetMaxWidthChars ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Int32+labelGetMaxWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_max_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method Label::get_mnemonic_keyval+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_mnemonic_keyval" gtk_label_get_mnemonic_keyval :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO Word32+++labelGetMnemonicKeyval ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Word32+labelGetMnemonicKeyval _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_mnemonic_keyval _obj'+    touchManagedPtr _obj+    return result++-- method Label::get_mnemonic_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_mnemonic_widget" gtk_label_get_mnemonic_widget :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO (Ptr Widget)+++labelGetMnemonicWidget ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Widget+labelGetMnemonicWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_mnemonic_widget _obj'+    checkUnexpectedReturnNULL "gtk_label_get_mnemonic_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Label::get_selectable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_selectable" gtk_label_get_selectable :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetSelectable ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetSelectable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_selectable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_selection_bounds+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "end", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_selection_bounds" gtk_label_get_selection_bounds :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Ptr Int32 ->                            -- start : TBasicType TInt32+    Ptr Int32 ->                            -- end : TBasicType TInt32+    IO CInt+++labelGetSelectionBounds ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m (Bool,Int32,Int32)+labelGetSelectionBounds _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    start <- allocMem :: IO (Ptr Int32)+    end <- allocMem :: IO (Ptr Int32)+    result <- gtk_label_get_selection_bounds _obj' start end+    let result' = (/= 0) result+    start' <- peek start+    end' <- peek end+    touchManagedPtr _obj+    freeMem start+    freeMem end+    return (result', start', end')++-- method Label::get_single_line_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_single_line_mode" gtk_label_get_single_line_mode :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetSingleLineMode ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetSingleLineMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_single_line_mode _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_text" gtk_label_get_text :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CString+++labelGetText ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m T.Text+labelGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_text _obj'+    checkUnexpectedReturnNULL "gtk_label_get_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Label::get_track_visited_links+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_track_visited_links" gtk_label_get_track_visited_links :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetTrackVisitedLinks ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetTrackVisitedLinks _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_track_visited_links _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_use_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_use_markup" gtk_label_get_use_markup :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetUseMarkup ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetUseMarkup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_use_markup _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_use_underline" gtk_label_get_use_underline :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CInt+++labelGetUseUnderline ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Bool+labelGetUseUnderline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_use_underline _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Label::get_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_width_chars" gtk_label_get_width_chars :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO Int32+++labelGetWidthChars ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Int32+labelGetWidthChars _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_width_chars _obj'+    touchManagedPtr _obj+    return result++-- method Label::get_xalign+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_xalign" gtk_label_get_xalign :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CFloat+++labelGetXalign ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Float+labelGetXalign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_xalign _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Label::get_yalign+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_get_yalign" gtk_label_get_yalign :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    IO CFloat+++labelGetYalign ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    m Float+labelGetYalign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_label_get_yalign _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Label::select_region+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start_offset", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end_offset", 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 "gtk_label_select_region" gtk_label_select_region :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Int32 ->                                -- start_offset : TBasicType TInt32+    Int32 ->                                -- end_offset : TBasicType TInt32+    IO ()+++labelSelectRegion ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- start_offset+    Int32 ->                                -- end_offset+    m ()+labelSelectRegion _obj start_offset end_offset = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_label_select_region _obj' start_offset end_offset+    touchManagedPtr _obj+    return ()++-- method Label::set_angle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "angle", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "angle", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_angle" gtk_label_set_angle :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CDouble ->                              -- angle : TBasicType TDouble+    IO ()+++labelSetAngle ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Double ->                               -- angle+    m ()+labelSetAngle _obj angle = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let angle' = realToFrac angle+    gtk_label_set_angle _obj' angle'+    touchManagedPtr _obj+    return ()++-- method Label::set_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attrs", argType = TInterface "Pango" "AttrList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attrs", argType = TInterface "Pango" "AttrList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_attributes" gtk_label_set_attributes :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Ptr Pango.AttrList ->                   -- attrs : TInterface "Pango" "AttrList"+    IO ()+++labelSetAttributes ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Maybe (Pango.AttrList) ->               -- attrs+    m ()+labelSetAttributes _obj attrs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAttrs <- case attrs of+        Nothing -> return nullPtr+        Just jAttrs -> do+            let jAttrs' = unsafeManagedPtrGetPtr jAttrs+            return jAttrs'+    gtk_label_set_attributes _obj' maybeAttrs+    touchManagedPtr _obj+    whenJust attrs touchManagedPtr+    return ()++-- method Label::set_ellipsize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Pango" "EllipsizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Pango" "EllipsizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_ellipsize" gtk_label_set_ellipsize :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CUInt ->                                -- mode : TInterface "Pango" "EllipsizeMode"+    IO ()+++labelSetEllipsize ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Pango.EllipsizeMode ->                  -- mode+    m ()+labelSetEllipsize _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_label_set_ellipsize _obj' mode'+    touchManagedPtr _obj+    return ()++-- method Label::set_justify+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "jtype", argType = TInterface "Gtk" "Justification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "jtype", argType = TInterface "Gtk" "Justification", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_justify" gtk_label_set_justify :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CUInt ->                                -- jtype : TInterface "Gtk" "Justification"+    IO ()+++labelSetJustify ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Justification ->                        -- jtype+    m ()+labelSetJustify _obj jtype = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let jtype' = (fromIntegral . fromEnum) jtype+    gtk_label_set_justify _obj' jtype'+    touchManagedPtr _obj+    return ()++-- method Label::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_label" gtk_label_set_label :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++labelSetLabel ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+labelSetLabel _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_label_set_label _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++-- method Label::set_line_wrap+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap", 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 "gtk_label_set_line_wrap" gtk_label_set_line_wrap :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- wrap : TBasicType TBoolean+    IO ()+++labelSetLineWrap ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- wrap+    m ()+labelSetLineWrap _obj wrap = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let wrap' = (fromIntegral . fromEnum) wrap+    gtk_label_set_line_wrap _obj' wrap'+    touchManagedPtr _obj+    return ()++-- method Label::set_line_wrap_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_mode", argType = TInterface "Pango" "WrapMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wrap_mode", argType = TInterface "Pango" "WrapMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_line_wrap_mode" gtk_label_set_line_wrap_mode :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CUInt ->                                -- wrap_mode : TInterface "Pango" "WrapMode"+    IO ()+++labelSetLineWrapMode ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Pango.WrapMode ->                       -- wrap_mode+    m ()+labelSetLineWrapMode _obj wrap_mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let wrap_mode' = (fromIntegral . fromEnum) wrap_mode+    gtk_label_set_line_wrap_mode _obj' wrap_mode'+    touchManagedPtr _obj+    return ()++-- method Label::set_lines+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lines", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lines", 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 "gtk_label_set_lines" gtk_label_set_lines :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Int32 ->                                -- lines : TBasicType TInt32+    IO ()+++labelSetLines ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- lines+    m ()+labelSetLines _obj lines = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_label_set_lines _obj' lines+    touchManagedPtr _obj+    return ()++-- method Label::set_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_markup" gtk_label_set_markup :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++labelSetMarkup ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+labelSetMarkup _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_label_set_markup _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++-- method Label::set_markup_with_mnemonic+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_markup_with_mnemonic" gtk_label_set_markup_with_mnemonic :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++labelSetMarkupWithMnemonic ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+labelSetMarkupWithMnemonic _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_label_set_markup_with_mnemonic _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++-- method Label::set_max_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_label_set_max_width_chars" gtk_label_set_max_width_chars :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++labelSetMaxWidthChars ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_chars+    m ()+labelSetMaxWidthChars _obj n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_label_set_max_width_chars _obj' n_chars+    touchManagedPtr _obj+    return ()++-- method Label::set_mnemonic_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_mnemonic_widget" gtk_label_set_mnemonic_widget :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++labelSetMnemonicWidget ::+    (MonadIO m, LabelK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- widget+    m ()+labelSetMnemonicWidget _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    gtk_label_set_mnemonic_widget _obj' maybeWidget+    touchManagedPtr _obj+    whenJust widget touchManagedPtr+    return ()++-- method Label::set_pattern+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pattern", 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 "gtk_label_set_pattern" gtk_label_set_pattern :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- pattern : TBasicType TUTF8+    IO ()+++labelSetPattern ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- pattern+    m ()+labelSetPattern _obj pattern = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    pattern' <- textToCString pattern+    gtk_label_set_pattern _obj' pattern'+    touchManagedPtr _obj+    freeMem pattern'+    return ()++-- method Label::set_selectable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_label_set_selectable" gtk_label_set_selectable :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++labelSetSelectable ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+labelSetSelectable _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_label_set_selectable _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Label::set_single_line_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single_line_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single_line_mode", 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 "gtk_label_set_single_line_mode" gtk_label_set_single_line_mode :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- single_line_mode : TBasicType TBoolean+    IO ()+++labelSetSingleLineMode ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- single_line_mode+    m ()+labelSetSingleLineMode _obj single_line_mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let single_line_mode' = (fromIntegral . fromEnum) single_line_mode+    gtk_label_set_single_line_mode _obj' single_line_mode'+    touchManagedPtr _obj+    return ()++-- method Label::set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_text" gtk_label_set_text :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++labelSetText ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+labelSetText _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_label_set_text _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++-- method Label::set_text_with_mnemonic+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_text_with_mnemonic" gtk_label_set_text_with_mnemonic :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++labelSetTextWithMnemonic ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+labelSetTextWithMnemonic _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_label_set_text_with_mnemonic _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++-- method Label::set_track_visited_links+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "track_links", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "track_links", 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 "gtk_label_set_track_visited_links" gtk_label_set_track_visited_links :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- track_links : TBasicType TBoolean+    IO ()+++labelSetTrackVisitedLinks ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- track_links+    m ()+labelSetTrackVisitedLinks _obj track_links = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let track_links' = (fromIntegral . fromEnum) track_links+    gtk_label_set_track_visited_links _obj' track_links'+    touchManagedPtr _obj+    return ()++-- method Label::set_use_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_label_set_use_markup" gtk_label_set_use_markup :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++labelSetUseMarkup ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+labelSetUseMarkup _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_label_set_use_markup _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Label::set_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_label_set_use_underline" gtk_label_set_use_underline :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++labelSetUseUnderline ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+labelSetUseUnderline _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_label_set_use_underline _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Label::set_width_chars+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_chars", 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 "gtk_label_set_width_chars" gtk_label_set_width_chars :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    Int32 ->                                -- n_chars : TBasicType TInt32+    IO ()+++labelSetWidthChars ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_chars+    m ()+labelSetWidthChars _obj n_chars = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_label_set_width_chars _obj' n_chars+    touchManagedPtr _obj+    return ()++-- method Label::set_xalign+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_xalign" gtk_label_set_xalign :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CFloat ->                               -- xalign : TBasicType TFloat+    IO ()+++labelSetXalign ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    m ()+labelSetXalign _obj xalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    gtk_label_set_xalign _obj' xalign'+    touchManagedPtr _obj+    return ()++-- method Label::set_yalign+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Label", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_label_set_yalign" gtk_label_set_yalign :: +    Ptr Label ->                            -- _obj : TInterface "Gtk" "Label"+    CFloat ->                               -- yalign : TBasicType TFloat+    IO ()+++labelSetYalign ::+    (MonadIO m, LabelK a) =>+    a ->                                    -- _obj+    Float ->                                -- yalign+    m ()+labelSetYalign _obj yalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let yalign' = realToFrac yalign+    gtk_label_set_yalign _obj' yalign'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Label.hs-boot view
@@ -0,0 +1,40 @@+module GI.Gtk.Objects.Label where++import Prelude ()+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 Label = Label (ForeignPtr Label)+instance GObject Label where+class GObject o => LabelK o+instance (GObject o, IsDescendantOf Label o) => LabelK o+data LabelAnglePropertyInfo+data LabelAttributesPropertyInfo+data LabelCursorPositionPropertyInfo+data LabelEllipsizePropertyInfo+data LabelJustifyPropertyInfo+data LabelLabelPropertyInfo+data LabelLinesPropertyInfo+data LabelMaxWidthCharsPropertyInfo+data LabelMnemonicKeyvalPropertyInfo+data LabelMnemonicWidgetPropertyInfo+data LabelPatternPropertyInfo+data LabelSelectablePropertyInfo+data LabelSelectionBoundPropertyInfo+data LabelSingleLineModePropertyInfo+data LabelTrackVisitedLinksPropertyInfo+data LabelUseMarkupPropertyInfo+data LabelUseUnderlinePropertyInfo+data LabelWidthCharsPropertyInfo+data LabelWrapPropertyInfo+data LabelWrapModePropertyInfo+data LabelXalignPropertyInfo+data LabelYalignPropertyInfo+data LabelActivateCurrentLinkSignalInfo+data LabelActivateLinkSignalInfo+data LabelCopyClipboardSignalInfo+data LabelMoveCursorSignalInfo+data LabelPopulatePopupSignalInfo
+ GI/Gtk/Objects/LabelAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.LabelAccessible+    ( ++-- * Exported types+    LabelAccessible(..)                     ,+    LabelAccessibleK                        ,+    toLabelAccessible                       ,+    noLabelAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LabelAccessible = LabelAccessible (ForeignPtr LabelAccessible)+foreign import ccall "gtk_label_accessible_get_type"+    c_gtk_label_accessible_get_type :: IO GType++type instance ParentTypes LabelAccessible = LabelAccessibleParentTypes+type LabelAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Hypertext, Atk.Text]++instance GObject LabelAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_label_accessible_get_type+    ++class GObject o => LabelAccessibleK o+instance (GObject o, IsDescendantOf LabelAccessible o) => LabelAccessibleK o++toLabelAccessible :: LabelAccessibleK o => o -> IO LabelAccessible+toLabelAccessible = unsafeCastTo LabelAccessible++noLabelAccessible :: Maybe LabelAccessible+noLabelAccessible = Nothing++type instance AttributeList LabelAccessible = LabelAccessibleAttributeList+type LabelAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList LabelAccessible = LabelAccessibleSignalList+type LabelAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("link-selected", Atk.HypertextLinkSelectedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("text-attributes-changed", Atk.TextTextAttributesChangedSignalInfo), '("text-caret-moved", Atk.TextTextCaretMovedSignalInfo), '("text-changed", Atk.TextTextChangedSignalInfo), '("text-insert", Atk.TextTextInsertSignalInfo), '("text-remove", Atk.TextTextRemoveSignalInfo), '("text-selection-changed", Atk.TextTextSelectionChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/LabelAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.LabelAccessible where++import Prelude ()+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 LabelAccessible = LabelAccessible (ForeignPtr LabelAccessible)+instance GObject LabelAccessible where+class GObject o => LabelAccessibleK o+instance (GObject o, IsDescendantOf LabelAccessible o) => LabelAccessibleK o
+ GI/Gtk/Objects/Layout.hs view
@@ -0,0 +1,472 @@++{- |+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.Gtk.Objects.Layout+    ( ++-- * Exported types+    Layout(..)                              ,+    LayoutK                                 ,+    toLayout                                ,+    noLayout                                ,+++ -- * Methods+-- ** layoutGetBinWindow+    layoutGetBinWindow                      ,+++-- ** layoutGetHadjustment+    layoutGetHadjustment                    ,+++-- ** layoutGetSize+    layoutGetSize                           ,+++-- ** layoutGetVadjustment+    layoutGetVadjustment                    ,+++-- ** layoutMove+    layoutMove                              ,+++-- ** layoutNew+    layoutNew                               ,+++-- ** layoutPut+    layoutPut                               ,+++-- ** layoutSetHadjustment+    layoutSetHadjustment                    ,+++-- ** layoutSetSize+    layoutSetSize                           ,+++-- ** layoutSetVadjustment+    layoutSetVadjustment                    ,+++++ -- * Properties+-- ** Height+    LayoutHeightPropertyInfo                ,+    constructLayoutHeight                   ,+    getLayoutHeight                         ,+    setLayoutHeight                         ,+++-- ** Width+    LayoutWidthPropertyInfo                 ,+    constructLayoutWidth                    ,+    getLayoutWidth                          ,+    setLayoutWidth                          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Layout = Layout (ForeignPtr Layout)+foreign import ccall "gtk_layout_get_type"+    c_gtk_layout_get_type :: IO GType++type instance ParentTypes Layout = LayoutParentTypes+type LayoutParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Scrollable]++instance GObject Layout where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_layout_get_type+    ++class GObject o => LayoutK o+instance (GObject o, IsDescendantOf Layout o) => LayoutK o++toLayout :: LayoutK o => o -> IO Layout+toLayout = unsafeCastTo Layout++noLayout :: Maybe Layout+noLayout = Nothing++-- VVV Prop "height"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getLayoutHeight :: (MonadIO m, LayoutK o) => o -> m Word32+getLayoutHeight obj = liftIO $ getObjectPropertyCUInt obj "height"++setLayoutHeight :: (MonadIO m, LayoutK o) => o -> Word32 -> m ()+setLayoutHeight obj val = liftIO $ setObjectPropertyCUInt obj "height" val++constructLayoutHeight :: Word32 -> IO ([Char], GValue)+constructLayoutHeight val = constructObjectPropertyCUInt "height" val++data LayoutHeightPropertyInfo+instance AttrInfo LayoutHeightPropertyInfo where+    type AttrAllowedOps LayoutHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LayoutHeightPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint LayoutHeightPropertyInfo = LayoutK+    type AttrGetType LayoutHeightPropertyInfo = Word32+    type AttrLabel LayoutHeightPropertyInfo = "Layout::height"+    attrGet _ = getLayoutHeight+    attrSet _ = setLayoutHeight+    attrConstruct _ = constructLayoutHeight++-- VVV Prop "width"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getLayoutWidth :: (MonadIO m, LayoutK o) => o -> m Word32+getLayoutWidth obj = liftIO $ getObjectPropertyCUInt obj "width"++setLayoutWidth :: (MonadIO m, LayoutK o) => o -> Word32 -> m ()+setLayoutWidth obj val = liftIO $ setObjectPropertyCUInt obj "width" val++constructLayoutWidth :: Word32 -> IO ([Char], GValue)+constructLayoutWidth val = constructObjectPropertyCUInt "width" val++data LayoutWidthPropertyInfo+instance AttrInfo LayoutWidthPropertyInfo where+    type AttrAllowedOps LayoutWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LayoutWidthPropertyInfo = (~) Word32+    type AttrBaseTypeConstraint LayoutWidthPropertyInfo = LayoutK+    type AttrGetType LayoutWidthPropertyInfo = Word32+    type AttrLabel LayoutWidthPropertyInfo = "Layout::width"+    attrGet _ = getLayoutWidth+    attrSet _ = setLayoutWidth+    attrConstruct _ = constructLayoutWidth++type instance AttributeList Layout = LayoutAttributeList+type LayoutAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("hadjustment", ScrollableHadjustmentPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height", LayoutHeightPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hscroll-policy", ScrollableHscrollPolicyPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("vadjustment", ScrollableVadjustmentPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("vscroll-policy", ScrollableVscrollPolicyPropertyInfo), '("width", LayoutWidthPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Layout = LayoutSignalList+type LayoutSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Layout::new+-- method type : Constructor+-- Args : [Arg {argName = "hadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "hadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "vadjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Layout"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_new" gtk_layout_new :: +    Ptr Adjustment ->                       -- hadjustment : TInterface "Gtk" "Adjustment"+    Ptr Adjustment ->                       -- vadjustment : TInterface "Gtk" "Adjustment"+    IO (Ptr Layout)+++layoutNew ::+    (MonadIO m, AdjustmentK a, AdjustmentK b) =>+    Maybe (a) ->                            -- hadjustment+    Maybe (b) ->                            -- vadjustment+    m Layout+layoutNew hadjustment vadjustment = liftIO $ do+    maybeHadjustment <- case hadjustment of+        Nothing -> return nullPtr+        Just jHadjustment -> do+            let jHadjustment' = unsafeManagedPtrCastPtr jHadjustment+            return jHadjustment'+    maybeVadjustment <- case vadjustment of+        Nothing -> return nullPtr+        Just jVadjustment -> do+            let jVadjustment' = unsafeManagedPtrCastPtr jVadjustment+            return jVadjustment'+    result <- gtk_layout_new maybeHadjustment maybeVadjustment+    checkUnexpectedReturnNULL "gtk_layout_new" result+    result' <- (newObject Layout) result+    whenJust hadjustment touchManagedPtr+    whenJust vadjustment touchManagedPtr+    return result'++-- method Layout::get_bin_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_get_bin_window" gtk_layout_get_bin_window :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    IO (Ptr Gdk.Window)+++layoutGetBinWindow ::+    (MonadIO m, LayoutK a) =>+    a ->                                    -- _obj+    m Gdk.Window+layoutGetBinWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_layout_get_bin_window _obj'+    checkUnexpectedReturnNULL "gtk_layout_get_bin_window" result+    result' <- (newObject Gdk.Window) result+    touchManagedPtr _obj+    return result'++-- method Layout::get_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_get_hadjustment" gtk_layout_get_hadjustment :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    IO (Ptr Adjustment)++{-# DEPRECATED layoutGetHadjustment ["(Since version 3.0)","Use gtk_scrollable_get_hadjustment()"]#-}+layoutGetHadjustment ::+    (MonadIO m, LayoutK a) =>+    a ->                                    -- _obj+    m Adjustment+layoutGetHadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_layout_get_hadjustment _obj'+    checkUnexpectedReturnNULL "gtk_layout_get_hadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Layout::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_get_size" gtk_layout_get_size :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Ptr Word32 ->                           -- width : TBasicType TUInt32+    Ptr Word32 ->                           -- height : TBasicType TUInt32+    IO ()+++layoutGetSize ::+    (MonadIO m, LayoutK a) =>+    a ->                                    -- _obj+    m (Word32,Word32)+layoutGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    width <- allocMem :: IO (Ptr Word32)+    height <- allocMem :: IO (Ptr Word32)+    gtk_layout_get_size _obj' width height+    width' <- peek width+    height' <- peek height+    touchManagedPtr _obj+    freeMem width+    freeMem height+    return (width', height')++-- method Layout::get_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_get_vadjustment" gtk_layout_get_vadjustment :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    IO (Ptr Adjustment)++{-# DEPRECATED layoutGetVadjustment ["(Since version 3.0)","Use gtk_scrollable_get_vadjustment()"]#-}+layoutGetVadjustment ::+    (MonadIO m, LayoutK a) =>+    a ->                                    -- _obj+    m Adjustment+layoutGetVadjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_layout_get_vadjustment _obj'+    checkUnexpectedReturnNULL "gtk_layout_get_vadjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Layout::move+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_layout_move" gtk_layout_move :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Ptr Widget ->                           -- child_widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO ()+++layoutMove ::+    (MonadIO m, LayoutK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child_widget+    Int32 ->                                -- x+    Int32 ->                                -- y+    m ()+layoutMove _obj child_widget x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child_widget' = unsafeManagedPtrCastPtr child_widget+    gtk_layout_move _obj' child_widget' x y+    touchManagedPtr _obj+    touchManagedPtr child_widget+    return ()++-- method Layout::put+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", 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 "gtk_layout_put" gtk_layout_put :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Ptr Widget ->                           -- child_widget : TInterface "Gtk" "Widget"+    Int32 ->                                -- x : TBasicType TInt32+    Int32 ->                                -- y : TBasicType TInt32+    IO ()+++layoutPut ::+    (MonadIO m, LayoutK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child_widget+    Int32 ->                                -- x+    Int32 ->                                -- y+    m ()+layoutPut _obj child_widget x y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child_widget' = unsafeManagedPtrCastPtr child_widget+    gtk_layout_put _obj' child_widget' x y+    touchManagedPtr _obj+    touchManagedPtr child_widget+    return ()++-- method Layout::set_hadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_set_hadjustment" gtk_layout_set_hadjustment :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()++{-# DEPRECATED layoutSetHadjustment ["(Since version 3.0)","Use gtk_scrollable_set_hadjustment()"]#-}+layoutSetHadjustment ::+    (MonadIO m, LayoutK a, AdjustmentK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- adjustment+    m ()+layoutSetHadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAdjustment <- case adjustment of+        Nothing -> return nullPtr+        Just jAdjustment -> do+            let jAdjustment' = unsafeManagedPtrCastPtr jAdjustment+            return jAdjustment'+    gtk_layout_set_hadjustment _obj' maybeAdjustment+    touchManagedPtr _obj+    whenJust adjustment touchManagedPtr+    return ()++-- method Layout::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", 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 "gtk_layout_set_size" gtk_layout_set_size :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Word32 ->                               -- width : TBasicType TUInt32+    Word32 ->                               -- height : TBasicType TUInt32+    IO ()+++layoutSetSize ::+    (MonadIO m, LayoutK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- width+    Word32 ->                               -- height+    m ()+layoutSetSize _obj width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_layout_set_size _obj' width height+    touchManagedPtr _obj+    return ()++-- method Layout::set_vadjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Layout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_layout_set_vadjustment" gtk_layout_set_vadjustment :: +    Ptr Layout ->                           -- _obj : TInterface "Gtk" "Layout"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()++{-# DEPRECATED layoutSetVadjustment ["(Since version 3.0)","Use gtk_scrollable_set_vadjustment()"]#-}+layoutSetVadjustment ::+    (MonadIO m, LayoutK a, AdjustmentK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- adjustment+    m ()+layoutSetVadjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAdjustment <- case adjustment of+        Nothing -> return nullPtr+        Just jAdjustment -> do+            let jAdjustment' = unsafeManagedPtrCastPtr jAdjustment+            return jAdjustment'+    gtk_layout_set_vadjustment _obj' maybeAdjustment+    touchManagedPtr _obj+    whenJust adjustment touchManagedPtr+    return ()++
+ GI/Gtk/Objects/Layout.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.Layout where++import Prelude ()+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 Layout = Layout (ForeignPtr Layout)+instance GObject Layout where+class GObject o => LayoutK o+instance (GObject o, IsDescendantOf Layout o) => LayoutK o+data LayoutHeightPropertyInfo+data LayoutWidthPropertyInfo
+ GI/Gtk/Objects/LevelBar.hs view
@@ -0,0 +1,753 @@++{- |+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.Gtk.Objects.LevelBar+    ( ++-- * Exported types+    LevelBar(..)                            ,+    LevelBarK                               ,+    toLevelBar                              ,+    noLevelBar                              ,+++ -- * Methods+-- ** levelBarAddOffsetValue+    levelBarAddOffsetValue                  ,+++-- ** levelBarGetInverted+    levelBarGetInverted                     ,+++-- ** levelBarGetMaxValue+    levelBarGetMaxValue                     ,+++-- ** levelBarGetMinValue+    levelBarGetMinValue                     ,+++-- ** levelBarGetMode+    levelBarGetMode                         ,+++-- ** levelBarGetOffsetValue+    levelBarGetOffsetValue                  ,+++-- ** levelBarGetValue+    levelBarGetValue                        ,+++-- ** levelBarNew+    levelBarNew                             ,+++-- ** levelBarNewForInterval+    levelBarNewForInterval                  ,+++-- ** levelBarRemoveOffsetValue+    levelBarRemoveOffsetValue               ,+++-- ** levelBarSetInverted+    levelBarSetInverted                     ,+++-- ** levelBarSetMaxValue+    levelBarSetMaxValue                     ,+++-- ** levelBarSetMinValue+    levelBarSetMinValue                     ,+++-- ** levelBarSetMode+    levelBarSetMode                         ,+++-- ** levelBarSetValue+    levelBarSetValue                        ,+++++ -- * Properties+-- ** Inverted+    LevelBarInvertedPropertyInfo            ,+    constructLevelBarInverted               ,+    getLevelBarInverted                     ,+    setLevelBarInverted                     ,+++-- ** MaxValue+    LevelBarMaxValuePropertyInfo            ,+    constructLevelBarMaxValue               ,+    getLevelBarMaxValue                     ,+    setLevelBarMaxValue                     ,+++-- ** MinValue+    LevelBarMinValuePropertyInfo            ,+    constructLevelBarMinValue               ,+    getLevelBarMinValue                     ,+    setLevelBarMinValue                     ,+++-- ** Mode+    LevelBarModePropertyInfo                ,+    constructLevelBarMode                   ,+    getLevelBarMode                         ,+    setLevelBarMode                         ,+++-- ** Value+    LevelBarValuePropertyInfo               ,+    constructLevelBarValue                  ,+    getLevelBarValue                        ,+    setLevelBarValue                        ,+++++ -- * Signals+-- ** OffsetChanged+    LevelBarOffsetChangedCallback           ,+    LevelBarOffsetChangedCallbackC          ,+    LevelBarOffsetChangedSignalInfo         ,+    afterLevelBarOffsetChanged              ,+    levelBarOffsetChangedCallbackWrapper    ,+    levelBarOffsetChangedClosure            ,+    mkLevelBarOffsetChangedCallback         ,+    noLevelBarOffsetChangedCallback         ,+    onLevelBarOffsetChanged                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LevelBar = LevelBar (ForeignPtr LevelBar)+foreign import ccall "gtk_level_bar_get_type"+    c_gtk_level_bar_get_type :: IO GType++type instance ParentTypes LevelBar = LevelBarParentTypes+type LevelBarParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject LevelBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_level_bar_get_type+    ++class GObject o => LevelBarK o+instance (GObject o, IsDescendantOf LevelBar o) => LevelBarK o++toLevelBar :: LevelBarK o => o -> IO LevelBar+toLevelBar = unsafeCastTo LevelBar++noLevelBar :: Maybe LevelBar+noLevelBar = Nothing++-- signal LevelBar::offset-changed+type LevelBarOffsetChangedCallback =+    T.Text ->+    IO ()++noLevelBarOffsetChangedCallback :: Maybe LevelBarOffsetChangedCallback+noLevelBarOffsetChangedCallback = Nothing++type LevelBarOffsetChangedCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkLevelBarOffsetChangedCallback :: LevelBarOffsetChangedCallbackC -> IO (FunPtr LevelBarOffsetChangedCallbackC)++levelBarOffsetChangedClosure :: LevelBarOffsetChangedCallback -> IO Closure+levelBarOffsetChangedClosure cb = newCClosure =<< mkLevelBarOffsetChangedCallback wrapped+    where wrapped = levelBarOffsetChangedCallbackWrapper cb++levelBarOffsetChangedCallbackWrapper ::+    LevelBarOffsetChangedCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+levelBarOffsetChangedCallbackWrapper _cb _ name _ = do+    name' <- cstringToText name+    _cb  name'++onLevelBarOffsetChanged :: (GObject a, MonadIO m) => a -> LevelBarOffsetChangedCallback -> m SignalHandlerId+onLevelBarOffsetChanged obj cb = liftIO $ connectLevelBarOffsetChanged obj cb SignalConnectBefore+afterLevelBarOffsetChanged :: (GObject a, MonadIO m) => a -> LevelBarOffsetChangedCallback -> m SignalHandlerId+afterLevelBarOffsetChanged obj cb = connectLevelBarOffsetChanged obj cb SignalConnectAfter++connectLevelBarOffsetChanged :: (GObject a, MonadIO m) =>+                                a -> LevelBarOffsetChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectLevelBarOffsetChanged obj cb after = liftIO $ do+    cb' <- mkLevelBarOffsetChangedCallback (levelBarOffsetChangedCallbackWrapper cb)+    connectSignalFunPtr obj "offset-changed" cb' after++-- VVV Prop "inverted"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLevelBarInverted :: (MonadIO m, LevelBarK o) => o -> m Bool+getLevelBarInverted obj = liftIO $ getObjectPropertyBool obj "inverted"++setLevelBarInverted :: (MonadIO m, LevelBarK o) => o -> Bool -> m ()+setLevelBarInverted obj val = liftIO $ setObjectPropertyBool obj "inverted" val++constructLevelBarInverted :: Bool -> IO ([Char], GValue)+constructLevelBarInverted val = constructObjectPropertyBool "inverted" val++data LevelBarInvertedPropertyInfo+instance AttrInfo LevelBarInvertedPropertyInfo where+    type AttrAllowedOps LevelBarInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LevelBarInvertedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LevelBarInvertedPropertyInfo = LevelBarK+    type AttrGetType LevelBarInvertedPropertyInfo = Bool+    type AttrLabel LevelBarInvertedPropertyInfo = "LevelBar::inverted"+    attrGet _ = getLevelBarInverted+    attrSet _ = setLevelBarInverted+    attrConstruct _ = constructLevelBarInverted++-- VVV Prop "max-value"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getLevelBarMaxValue :: (MonadIO m, LevelBarK o) => o -> m Double+getLevelBarMaxValue obj = liftIO $ getObjectPropertyDouble obj "max-value"++setLevelBarMaxValue :: (MonadIO m, LevelBarK o) => o -> Double -> m ()+setLevelBarMaxValue obj val = liftIO $ setObjectPropertyDouble obj "max-value" val++constructLevelBarMaxValue :: Double -> IO ([Char], GValue)+constructLevelBarMaxValue val = constructObjectPropertyDouble "max-value" val++data LevelBarMaxValuePropertyInfo+instance AttrInfo LevelBarMaxValuePropertyInfo where+    type AttrAllowedOps LevelBarMaxValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LevelBarMaxValuePropertyInfo = (~) Double+    type AttrBaseTypeConstraint LevelBarMaxValuePropertyInfo = LevelBarK+    type AttrGetType LevelBarMaxValuePropertyInfo = Double+    type AttrLabel LevelBarMaxValuePropertyInfo = "LevelBar::max-value"+    attrGet _ = getLevelBarMaxValue+    attrSet _ = setLevelBarMaxValue+    attrConstruct _ = constructLevelBarMaxValue++-- VVV Prop "min-value"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getLevelBarMinValue :: (MonadIO m, LevelBarK o) => o -> m Double+getLevelBarMinValue obj = liftIO $ getObjectPropertyDouble obj "min-value"++setLevelBarMinValue :: (MonadIO m, LevelBarK o) => o -> Double -> m ()+setLevelBarMinValue obj val = liftIO $ setObjectPropertyDouble obj "min-value" val++constructLevelBarMinValue :: Double -> IO ([Char], GValue)+constructLevelBarMinValue val = constructObjectPropertyDouble "min-value" val++data LevelBarMinValuePropertyInfo+instance AttrInfo LevelBarMinValuePropertyInfo where+    type AttrAllowedOps LevelBarMinValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LevelBarMinValuePropertyInfo = (~) Double+    type AttrBaseTypeConstraint LevelBarMinValuePropertyInfo = LevelBarK+    type AttrGetType LevelBarMinValuePropertyInfo = Double+    type AttrLabel LevelBarMinValuePropertyInfo = "LevelBar::min-value"+    attrGet _ = getLevelBarMinValue+    attrSet _ = setLevelBarMinValue+    attrConstruct _ = constructLevelBarMinValue++-- VVV Prop "mode"+   -- Type: TInterface "Gtk" "LevelBarMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getLevelBarMode :: (MonadIO m, LevelBarK o) => o -> m LevelBarMode+getLevelBarMode obj = liftIO $ getObjectPropertyEnum obj "mode"++setLevelBarMode :: (MonadIO m, LevelBarK o) => o -> LevelBarMode -> m ()+setLevelBarMode obj val = liftIO $ setObjectPropertyEnum obj "mode" val++constructLevelBarMode :: LevelBarMode -> IO ([Char], GValue)+constructLevelBarMode val = constructObjectPropertyEnum "mode" val++data LevelBarModePropertyInfo+instance AttrInfo LevelBarModePropertyInfo where+    type AttrAllowedOps LevelBarModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LevelBarModePropertyInfo = (~) LevelBarMode+    type AttrBaseTypeConstraint LevelBarModePropertyInfo = LevelBarK+    type AttrGetType LevelBarModePropertyInfo = LevelBarMode+    type AttrLabel LevelBarModePropertyInfo = "LevelBar::mode"+    attrGet _ = getLevelBarMode+    attrSet _ = setLevelBarMode+    attrConstruct _ = constructLevelBarMode++-- VVV Prop "value"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getLevelBarValue :: (MonadIO m, LevelBarK o) => o -> m Double+getLevelBarValue obj = liftIO $ getObjectPropertyDouble obj "value"++setLevelBarValue :: (MonadIO m, LevelBarK o) => o -> Double -> m ()+setLevelBarValue obj val = liftIO $ setObjectPropertyDouble obj "value" val++constructLevelBarValue :: Double -> IO ([Char], GValue)+constructLevelBarValue val = constructObjectPropertyDouble "value" val++data LevelBarValuePropertyInfo+instance AttrInfo LevelBarValuePropertyInfo where+    type AttrAllowedOps LevelBarValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LevelBarValuePropertyInfo = (~) Double+    type AttrBaseTypeConstraint LevelBarValuePropertyInfo = LevelBarK+    type AttrGetType LevelBarValuePropertyInfo = Double+    type AttrLabel LevelBarValuePropertyInfo = "LevelBar::value"+    attrGet _ = getLevelBarValue+    attrSet _ = setLevelBarValue+    attrConstruct _ = constructLevelBarValue++type instance AttributeList LevelBar = LevelBarAttributeList+type LevelBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inverted", LevelBarInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-value", LevelBarMaxValuePropertyInfo), '("min-value", LevelBarMinValuePropertyInfo), '("mode", LevelBarModePropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("value", LevelBarValuePropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data LevelBarOffsetChangedSignalInfo+instance SignalInfo LevelBarOffsetChangedSignalInfo where+    type HaskellCallbackType LevelBarOffsetChangedSignalInfo = LevelBarOffsetChangedCallback+    connectSignal _ = connectLevelBarOffsetChanged++type instance SignalList LevelBar = LevelBarSignalList+type LevelBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("offset-changed", LevelBarOffsetChangedSignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method LevelBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "LevelBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_new" gtk_level_bar_new :: +    IO (Ptr LevelBar)+++levelBarNew ::+    (MonadIO m) =>+    m LevelBar+levelBarNew  = liftIO $ do+    result <- gtk_level_bar_new+    checkUnexpectedReturnNULL "gtk_level_bar_new" result+    result' <- (newObject LevelBar) result+    return result'++-- method LevelBar::new_for_interval+-- method type : Constructor+-- Args : [Arg {argName = "min_value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max_value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "min_value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max_value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "LevelBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_new_for_interval" gtk_level_bar_new_for_interval :: +    CDouble ->                              -- min_value : TBasicType TDouble+    CDouble ->                              -- max_value : TBasicType TDouble+    IO (Ptr LevelBar)+++levelBarNewForInterval ::+    (MonadIO m) =>+    Double ->                               -- min_value+    Double ->                               -- max_value+    m LevelBar+levelBarNewForInterval min_value max_value = liftIO $ do+    let min_value' = realToFrac min_value+    let max_value' = realToFrac max_value+    result <- gtk_level_bar_new_for_interval min_value' max_value'+    checkUnexpectedReturnNULL "gtk_level_bar_new_for_interval" result+    result' <- (newObject LevelBar) result+    return result'++-- method LevelBar::add_offset_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_add_offset_value" gtk_level_bar_add_offset_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CString ->                              -- name : TBasicType TUTF8+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++levelBarAddOffsetValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    Double ->                               -- value+    m ()+levelBarAddOffsetValue _obj name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    let value' = realToFrac value+    gtk_level_bar_add_offset_value _obj' name' value'+    touchManagedPtr _obj+    freeMem name'+    return ()++-- method LevelBar::get_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_inverted" gtk_level_bar_get_inverted :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    IO CInt+++levelBarGetInverted ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    m Bool+levelBarGetInverted _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_level_bar_get_inverted _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method LevelBar::get_max_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_max_value" gtk_level_bar_get_max_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    IO CDouble+++levelBarGetMaxValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    m Double+levelBarGetMaxValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_level_bar_get_max_value _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method LevelBar::get_min_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_min_value" gtk_level_bar_get_min_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    IO CDouble+++levelBarGetMinValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    m Double+levelBarGetMinValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_level_bar_get_min_value _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method LevelBar::get_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "LevelBarMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_mode" gtk_level_bar_get_mode :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    IO CUInt+++levelBarGetMode ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    m LevelBarMode+levelBarGetMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_level_bar_get_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method LevelBar::get_offset_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_offset_value" gtk_level_bar_get_offset_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CString ->                              -- name : TBasicType TUTF8+    Ptr CDouble ->                          -- value : TBasicType TDouble+    IO CInt+++levelBarGetOffsetValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- name+    m (Bool,Double)+levelBarGetOffsetValue _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    value <- allocMem :: IO (Ptr CDouble)+    result <- gtk_level_bar_get_offset_value _obj' maybeName value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem maybeName+    freeMem value+    return (result', value'')++-- method LevelBar::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_get_value" gtk_level_bar_get_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    IO CDouble+++levelBarGetValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    m Double+levelBarGetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_level_bar_get_value _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method LevelBar::remove_offset_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_remove_offset_value" gtk_level_bar_remove_offset_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++levelBarRemoveOffsetValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- name+    m ()+levelBarRemoveOffsetValue _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    gtk_level_bar_remove_offset_value _obj' maybeName+    touchManagedPtr _obj+    freeMem maybeName+    return ()++-- method LevelBar::set_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 "Gtk" "LevelBar", 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 "gtk_level_bar_set_inverted" gtk_level_bar_set_inverted :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CInt ->                                 -- inverted : TBasicType TBoolean+    IO ()+++levelBarSetInverted ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- inverted+    m ()+levelBarSetInverted _obj inverted = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let inverted' = (fromIntegral . fromEnum) inverted+    gtk_level_bar_set_inverted _obj' inverted'+    touchManagedPtr _obj+    return ()++-- method LevelBar::set_max_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 "Gtk" "LevelBar", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_set_max_value" gtk_level_bar_set_max_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++levelBarSetMaxValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    m ()+levelBarSetMaxValue _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    gtk_level_bar_set_max_value _obj' value'+    touchManagedPtr _obj+    return ()++-- method LevelBar::set_min_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 "Gtk" "LevelBar", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_set_min_value" gtk_level_bar_set_min_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++levelBarSetMinValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    m ()+levelBarSetMinValue _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    gtk_level_bar_set_min_value _obj' value'+    touchManagedPtr _obj+    return ()++-- method LevelBar::set_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "LevelBarMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "LevelBarMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_set_mode" gtk_level_bar_set_mode :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CUInt ->                                -- mode : TInterface "Gtk" "LevelBarMode"+    IO ()+++levelBarSetMode ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    LevelBarMode ->                         -- mode+    m ()+levelBarSetMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_level_bar_set_mode _obj' mode'+    touchManagedPtr _obj+    return ()++-- method LevelBar::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LevelBar", 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 "Gtk" "LevelBar", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_level_bar_set_value" gtk_level_bar_set_value :: +    Ptr LevelBar ->                         -- _obj : TInterface "Gtk" "LevelBar"+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++levelBarSetValue ::+    (MonadIO m, LevelBarK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    m ()+levelBarSetValue _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    gtk_level_bar_set_value _obj' value'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/LevelBar.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.LevelBar where++import Prelude ()+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 LevelBar = LevelBar (ForeignPtr LevelBar)+instance GObject LevelBar where+class GObject o => LevelBarK o+instance (GObject o, IsDescendantOf LevelBar o) => LevelBarK o+data LevelBarInvertedPropertyInfo+data LevelBarMaxValuePropertyInfo+data LevelBarMinValuePropertyInfo+data LevelBarModePropertyInfo+data LevelBarValuePropertyInfo+data LevelBarOffsetChangedSignalInfo
+ GI/Gtk/Objects/LevelBarAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.LevelBarAccessible+    ( ++-- * Exported types+    LevelBarAccessible(..)                  ,+    LevelBarAccessibleK                     ,+    toLevelBarAccessible                    ,+    noLevelBarAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LevelBarAccessible = LevelBarAccessible (ForeignPtr LevelBarAccessible)+foreign import ccall "gtk_level_bar_accessible_get_type"+    c_gtk_level_bar_accessible_get_type :: IO GType++type instance ParentTypes LevelBarAccessible = LevelBarAccessibleParentTypes+type LevelBarAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Value]++instance GObject LevelBarAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_level_bar_accessible_get_type+    ++class GObject o => LevelBarAccessibleK o+instance (GObject o, IsDescendantOf LevelBarAccessible o) => LevelBarAccessibleK o++toLevelBarAccessible :: LevelBarAccessibleK o => o -> IO LevelBarAccessible+toLevelBarAccessible = unsafeCastTo LevelBarAccessible++noLevelBarAccessible :: Maybe LevelBarAccessible+noLevelBarAccessible = Nothing++type instance AttributeList LevelBarAccessible = LevelBarAccessibleAttributeList+type LevelBarAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList LevelBarAccessible = LevelBarAccessibleSignalList+type LevelBarAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("value-changed", Atk.ValueValueChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/LevelBarAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.LevelBarAccessible where++import Prelude ()+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 LevelBarAccessible = LevelBarAccessible (ForeignPtr LevelBarAccessible)+instance GObject LevelBarAccessible where+class GObject o => LevelBarAccessibleK o+instance (GObject o, IsDescendantOf LevelBarAccessible o) => LevelBarAccessibleK o
+ GI/Gtk/Objects/LinkButton.hs view
@@ -0,0 +1,377 @@++{- |+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.Gtk.Objects.LinkButton+    ( ++-- * Exported types+    LinkButton(..)                          ,+    LinkButtonK                             ,+    toLinkButton                            ,+    noLinkButton                            ,+++ -- * Methods+-- ** linkButtonGetUri+    linkButtonGetUri                        ,+++-- ** linkButtonGetVisited+    linkButtonGetVisited                    ,+++-- ** linkButtonNew+    linkButtonNew                           ,+++-- ** linkButtonNewWithLabel+    linkButtonNewWithLabel                  ,+++-- ** linkButtonSetUri+    linkButtonSetUri                        ,+++-- ** linkButtonSetVisited+    linkButtonSetVisited                    ,+++++ -- * Properties+-- ** Uri+    LinkButtonUriPropertyInfo               ,+    constructLinkButtonUri                  ,+    getLinkButtonUri                        ,+    setLinkButtonUri                        ,+++-- ** Visited+    LinkButtonVisitedPropertyInfo           ,+    constructLinkButtonVisited              ,+    getLinkButtonVisited                    ,+    setLinkButtonVisited                    ,+++++ -- * Signals+-- ** ActivateLink+    LinkButtonActivateLinkCallback          ,+    LinkButtonActivateLinkCallbackC         ,+    LinkButtonActivateLinkSignalInfo        ,+    afterLinkButtonActivateLink             ,+    linkButtonActivateLinkCallbackWrapper   ,+    linkButtonActivateLinkClosure           ,+    mkLinkButtonActivateLinkCallback        ,+    noLinkButtonActivateLinkCallback        ,+    onLinkButtonActivateLink                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LinkButton = LinkButton (ForeignPtr LinkButton)+foreign import ccall "gtk_link_button_get_type"+    c_gtk_link_button_get_type :: IO GType++type instance ParentTypes LinkButton = LinkButtonParentTypes+type LinkButtonParentTypes = '[Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject LinkButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_link_button_get_type+    ++class GObject o => LinkButtonK o+instance (GObject o, IsDescendantOf LinkButton o) => LinkButtonK o++toLinkButton :: LinkButtonK o => o -> IO LinkButton+toLinkButton = unsafeCastTo LinkButton++noLinkButton :: Maybe LinkButton+noLinkButton = Nothing++-- signal LinkButton::activate-link+type LinkButtonActivateLinkCallback =+    IO Bool++noLinkButtonActivateLinkCallback :: Maybe LinkButtonActivateLinkCallback+noLinkButtonActivateLinkCallback = Nothing++type LinkButtonActivateLinkCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkLinkButtonActivateLinkCallback :: LinkButtonActivateLinkCallbackC -> IO (FunPtr LinkButtonActivateLinkCallbackC)++linkButtonActivateLinkClosure :: LinkButtonActivateLinkCallback -> IO Closure+linkButtonActivateLinkClosure cb = newCClosure =<< mkLinkButtonActivateLinkCallback wrapped+    where wrapped = linkButtonActivateLinkCallbackWrapper cb++linkButtonActivateLinkCallbackWrapper ::+    LinkButtonActivateLinkCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+linkButtonActivateLinkCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onLinkButtonActivateLink :: (GObject a, MonadIO m) => a -> LinkButtonActivateLinkCallback -> m SignalHandlerId+onLinkButtonActivateLink obj cb = liftIO $ connectLinkButtonActivateLink obj cb SignalConnectBefore+afterLinkButtonActivateLink :: (GObject a, MonadIO m) => a -> LinkButtonActivateLinkCallback -> m SignalHandlerId+afterLinkButtonActivateLink obj cb = connectLinkButtonActivateLink obj cb SignalConnectAfter++connectLinkButtonActivateLink :: (GObject a, MonadIO m) =>+                                 a -> LinkButtonActivateLinkCallback -> SignalConnectMode -> m SignalHandlerId+connectLinkButtonActivateLink obj cb after = liftIO $ do+    cb' <- mkLinkButtonActivateLinkCallback (linkButtonActivateLinkCallbackWrapper cb)+    connectSignalFunPtr obj "activate-link" cb' after++-- VVV Prop "uri"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getLinkButtonUri :: (MonadIO m, LinkButtonK o) => o -> m T.Text+getLinkButtonUri obj = liftIO $ getObjectPropertyString obj "uri"++setLinkButtonUri :: (MonadIO m, LinkButtonK o) => o -> T.Text -> m ()+setLinkButtonUri obj val = liftIO $ setObjectPropertyString obj "uri" val++constructLinkButtonUri :: T.Text -> IO ([Char], GValue)+constructLinkButtonUri val = constructObjectPropertyString "uri" val++data LinkButtonUriPropertyInfo+instance AttrInfo LinkButtonUriPropertyInfo where+    type AttrAllowedOps LinkButtonUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LinkButtonUriPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LinkButtonUriPropertyInfo = LinkButtonK+    type AttrGetType LinkButtonUriPropertyInfo = T.Text+    type AttrLabel LinkButtonUriPropertyInfo = "LinkButton::uri"+    attrGet _ = getLinkButtonUri+    attrSet _ = setLinkButtonUri+    attrConstruct _ = constructLinkButtonUri++-- VVV Prop "visited"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getLinkButtonVisited :: (MonadIO m, LinkButtonK o) => o -> m Bool+getLinkButtonVisited obj = liftIO $ getObjectPropertyBool obj "visited"++setLinkButtonVisited :: (MonadIO m, LinkButtonK o) => o -> Bool -> m ()+setLinkButtonVisited obj val = liftIO $ setObjectPropertyBool obj "visited" val++constructLinkButtonVisited :: Bool -> IO ([Char], GValue)+constructLinkButtonVisited val = constructObjectPropertyBool "visited" val++data LinkButtonVisitedPropertyInfo+instance AttrInfo LinkButtonVisitedPropertyInfo where+    type AttrAllowedOps LinkButtonVisitedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LinkButtonVisitedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint LinkButtonVisitedPropertyInfo = LinkButtonK+    type AttrGetType LinkButtonVisitedPropertyInfo = Bool+    type AttrLabel LinkButtonVisitedPropertyInfo = "LinkButton::visited"+    attrGet _ = getLinkButtonVisited+    attrSet _ = setLinkButtonVisited+    attrConstruct _ = constructLinkButtonVisited++type instance AttributeList LinkButton = LinkButtonAttributeList+type LinkButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("uri", LinkButtonUriPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("visited", LinkButtonVisitedPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++data LinkButtonActivateLinkSignalInfo+instance SignalInfo LinkButtonActivateLinkSignalInfo where+    type HaskellCallbackType LinkButtonActivateLinkSignalInfo = LinkButtonActivateLinkCallback+    connectSignal _ = connectLinkButtonActivateLink++type instance SignalList LinkButton = LinkButtonSignalList+type LinkButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("activate-link", LinkButtonActivateLinkSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method LinkButton::new+-- method type : Constructor+-- 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 "Gtk" "LinkButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_link_button_new" gtk_link_button_new :: +    CString ->                              -- uri : TBasicType TUTF8+    IO (Ptr LinkButton)+++linkButtonNew ::+    (MonadIO m) =>+    T.Text ->                               -- uri+    m LinkButton+linkButtonNew uri = liftIO $ do+    uri' <- textToCString uri+    result <- gtk_link_button_new uri'+    checkUnexpectedReturnNULL "gtk_link_button_new" result+    result' <- (newObject LinkButton) result+    freeMem uri'+    return result'++-- method LinkButton::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "uri", argType = TBasicType TUTF8, 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 = "uri", argType = TBasicType TUTF8, 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 : TInterface "Gtk" "LinkButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_link_button_new_with_label" gtk_link_button_new_with_label :: +    CString ->                              -- uri : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr LinkButton)+++linkButtonNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- uri+    Maybe (T.Text) ->                       -- label+    m LinkButton+linkButtonNewWithLabel uri label = liftIO $ do+    uri' <- textToCString uri+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_link_button_new_with_label uri' maybeLabel+    checkUnexpectedReturnNULL "gtk_link_button_new_with_label" result+    result' <- (newObject LinkButton) result+    freeMem uri'+    freeMem maybeLabel+    return result'++-- method LinkButton::get_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_link_button_get_uri" gtk_link_button_get_uri :: +    Ptr LinkButton ->                       -- _obj : TInterface "Gtk" "LinkButton"+    IO CString+++linkButtonGetUri ::+    (MonadIO m, LinkButtonK a) =>+    a ->                                    -- _obj+    m T.Text+linkButtonGetUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_link_button_get_uri _obj'+    checkUnexpectedReturnNULL "gtk_link_button_get_uri" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method LinkButton::get_visited+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_link_button_get_visited" gtk_link_button_get_visited :: +    Ptr LinkButton ->                       -- _obj : TInterface "Gtk" "LinkButton"+    IO CInt+++linkButtonGetVisited ::+    (MonadIO m, LinkButtonK a) =>+    a ->                                    -- _obj+    m Bool+linkButtonGetVisited _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_link_button_get_visited _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method LinkButton::set_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", 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 "Gtk" "LinkButton", 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 : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_link_button_set_uri" gtk_link_button_set_uri :: +    Ptr LinkButton ->                       -- _obj : TInterface "Gtk" "LinkButton"+    CString ->                              -- uri : TBasicType TUTF8+    IO ()+++linkButtonSetUri ::+    (MonadIO m, LinkButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+linkButtonSetUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    gtk_link_button_set_uri _obj' uri'+    touchManagedPtr _obj+    freeMem uri'+    return ()++-- method LinkButton::set_visited+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visited", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LinkButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visited", 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 "gtk_link_button_set_visited" gtk_link_button_set_visited :: +    Ptr LinkButton ->                       -- _obj : TInterface "Gtk" "LinkButton"+    CInt ->                                 -- visited : TBasicType TBoolean+    IO ()+++linkButtonSetVisited ::+    (MonadIO m, LinkButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- visited+    m ()+linkButtonSetVisited _obj visited = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visited' = (fromIntegral . fromEnum) visited+    gtk_link_button_set_visited _obj' visited'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/LinkButton.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.LinkButton where++import Prelude ()+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 LinkButton = LinkButton (ForeignPtr LinkButton)+instance GObject LinkButton where+class GObject o => LinkButtonK o+instance (GObject o, IsDescendantOf LinkButton o) => LinkButtonK o+data LinkButtonUriPropertyInfo+data LinkButtonVisitedPropertyInfo+data LinkButtonActivateLinkSignalInfo
+ GI/Gtk/Objects/LinkButtonAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.LinkButtonAccessible+    ( ++-- * Exported types+    LinkButtonAccessible(..)                ,+    LinkButtonAccessibleK                   ,+    toLinkButtonAccessible                  ,+    noLinkButtonAccessible                  ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LinkButtonAccessible = LinkButtonAccessible (ForeignPtr LinkButtonAccessible)+foreign import ccall "gtk_link_button_accessible_get_type"+    c_gtk_link_button_accessible_get_type :: IO GType++type instance ParentTypes LinkButtonAccessible = LinkButtonAccessibleParentTypes+type LinkButtonAccessibleParentTypes = '[ButtonAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.HyperlinkImpl, Atk.Image]++instance GObject LinkButtonAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_link_button_accessible_get_type+    ++class GObject o => LinkButtonAccessibleK o+instance (GObject o, IsDescendantOf LinkButtonAccessible o) => LinkButtonAccessibleK o++toLinkButtonAccessible :: LinkButtonAccessibleK o => o -> IO LinkButtonAccessible+toLinkButtonAccessible = unsafeCastTo LinkButtonAccessible++noLinkButtonAccessible :: Maybe LinkButtonAccessible+noLinkButtonAccessible = Nothing++type instance AttributeList LinkButtonAccessible = LinkButtonAccessibleAttributeList+type LinkButtonAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList LinkButtonAccessible = LinkButtonAccessibleSignalList+type LinkButtonAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/LinkButtonAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.LinkButtonAccessible where++import Prelude ()+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 LinkButtonAccessible = LinkButtonAccessible (ForeignPtr LinkButtonAccessible)+instance GObject LinkButtonAccessible where+class GObject o => LinkButtonAccessibleK o+instance (GObject o, IsDescendantOf LinkButtonAccessible o) => LinkButtonAccessibleK o
+ GI/Gtk/Objects/ListBox.hs view
@@ -0,0 +1,1498 @@++{- |+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.Gtk.Objects.ListBox+    ( ++-- * Exported types+    ListBox(..)                             ,+    ListBoxK                                ,+    toListBox                               ,+    noListBox                               ,+++ -- * Methods+-- ** listBoxBindModel+    listBoxBindModel                        ,+++-- ** listBoxDragHighlightRow+    listBoxDragHighlightRow                 ,+++-- ** listBoxDragUnhighlightRow+    listBoxDragUnhighlightRow               ,+++-- ** listBoxGetActivateOnSingleClick+    listBoxGetActivateOnSingleClick         ,+++-- ** listBoxGetAdjustment+    listBoxGetAdjustment                    ,+++-- ** listBoxGetRowAtIndex+    listBoxGetRowAtIndex                    ,+++-- ** listBoxGetRowAtY+    listBoxGetRowAtY                        ,+++-- ** listBoxGetSelectedRow+    listBoxGetSelectedRow                   ,+++-- ** listBoxGetSelectedRows+    listBoxGetSelectedRows                  ,+++-- ** listBoxGetSelectionMode+    listBoxGetSelectionMode                 ,+++-- ** listBoxInsert+    listBoxInsert                           ,+++-- ** listBoxInvalidateFilter+    listBoxInvalidateFilter                 ,+++-- ** listBoxInvalidateHeaders+    listBoxInvalidateHeaders                ,+++-- ** listBoxInvalidateSort+    listBoxInvalidateSort                   ,+++-- ** listBoxNew+    listBoxNew                              ,+++-- ** listBoxPrepend+    listBoxPrepend                          ,+++-- ** listBoxSelectAll+    listBoxSelectAll                        ,+++-- ** listBoxSelectRow+    listBoxSelectRow                        ,+++-- ** listBoxSelectedForeach+    listBoxSelectedForeach                  ,+++-- ** listBoxSetActivateOnSingleClick+    listBoxSetActivateOnSingleClick         ,+++-- ** listBoxSetAdjustment+    listBoxSetAdjustment                    ,+++-- ** listBoxSetFilterFunc+    listBoxSetFilterFunc                    ,+++-- ** listBoxSetHeaderFunc+    listBoxSetHeaderFunc                    ,+++-- ** listBoxSetPlaceholder+    listBoxSetPlaceholder                   ,+++-- ** listBoxSetSelectionMode+    listBoxSetSelectionMode                 ,+++-- ** listBoxSetSortFunc+    listBoxSetSortFunc                      ,+++-- ** listBoxUnselectAll+    listBoxUnselectAll                      ,+++-- ** listBoxUnselectRow+    listBoxUnselectRow                      ,+++++ -- * Properties+-- ** ActivateOnSingleClick+    ListBoxActivateOnSingleClickPropertyInfo,+    constructListBoxActivateOnSingleClick   ,+    getListBoxActivateOnSingleClick         ,+    setListBoxActivateOnSingleClick         ,+++-- ** SelectionMode+    ListBoxSelectionModePropertyInfo        ,+    constructListBoxSelectionMode           ,+    getListBoxSelectionMode                 ,+    setListBoxSelectionMode                 ,+++++ -- * Signals+-- ** ActivateCursorRow+    ListBoxActivateCursorRowCallback        ,+    ListBoxActivateCursorRowCallbackC       ,+    ListBoxActivateCursorRowSignalInfo      ,+    afterListBoxActivateCursorRow           ,+    listBoxActivateCursorRowCallbackWrapper ,+    listBoxActivateCursorRowClosure         ,+    mkListBoxActivateCursorRowCallback      ,+    noListBoxActivateCursorRowCallback      ,+    onListBoxActivateCursorRow              ,+++-- ** MoveCursor+    ListBoxMoveCursorCallback               ,+    ListBoxMoveCursorCallbackC              ,+    ListBoxMoveCursorSignalInfo             ,+    afterListBoxMoveCursor                  ,+    listBoxMoveCursorCallbackWrapper        ,+    listBoxMoveCursorClosure                ,+    mkListBoxMoveCursorCallback             ,+    noListBoxMoveCursorCallback             ,+    onListBoxMoveCursor                     ,+++-- ** RowActivated+    ListBoxRowActivatedCallback             ,+    ListBoxRowActivatedCallbackC            ,+    ListBoxRowActivatedSignalInfo           ,+    afterListBoxRowActivated                ,+    listBoxRowActivatedCallbackWrapper      ,+    listBoxRowActivatedClosure              ,+    mkListBoxRowActivatedCallback           ,+    noListBoxRowActivatedCallback           ,+    onListBoxRowActivated                   ,+++-- ** RowSelected+    ListBoxRowSelectedCallback              ,+    ListBoxRowSelectedCallbackC             ,+    ListBoxRowSelectedSignalInfo            ,+    afterListBoxRowSelected                 ,+    listBoxRowSelectedCallbackWrapper       ,+    listBoxRowSelectedClosure               ,+    mkListBoxRowSelectedCallback            ,+    noListBoxRowSelectedCallback            ,+    onListBoxRowSelected                    ,+++-- ** SelectAll+    ListBoxSelectAllCallback                ,+    ListBoxSelectAllCallbackC               ,+    ListBoxSelectAllSignalInfo              ,+    afterListBoxSelectAll                   ,+    listBoxSelectAllCallbackWrapper         ,+    listBoxSelectAllClosure                 ,+    mkListBoxSelectAllCallback              ,+    noListBoxSelectAllCallback              ,+    onListBoxSelectAll                      ,+++-- ** SelectedRowsChanged+    ListBoxSelectedRowsChangedCallback      ,+    ListBoxSelectedRowsChangedCallbackC     ,+    ListBoxSelectedRowsChangedSignalInfo    ,+    afterListBoxSelectedRowsChanged         ,+    listBoxSelectedRowsChangedCallbackWrapper,+    listBoxSelectedRowsChangedClosure       ,+    mkListBoxSelectedRowsChangedCallback    ,+    noListBoxSelectedRowsChangedCallback    ,+    onListBoxSelectedRowsChanged            ,+++-- ** ToggleCursorRow+    ListBoxToggleCursorRowCallback          ,+    ListBoxToggleCursorRowCallbackC         ,+    ListBoxToggleCursorRowSignalInfo        ,+    afterListBoxToggleCursorRow             ,+    listBoxToggleCursorRowCallbackWrapper   ,+    listBoxToggleCursorRowClosure           ,+    mkListBoxToggleCursorRowCallback        ,+    noListBoxToggleCursorRowCallback        ,+    onListBoxToggleCursorRow                ,+++-- ** UnselectAll+    ListBoxUnselectAllCallback              ,+    ListBoxUnselectAllCallbackC             ,+    ListBoxUnselectAllSignalInfo            ,+    afterListBoxUnselectAll                 ,+    listBoxUnselectAllCallbackWrapper       ,+    listBoxUnselectAllClosure               ,+    mkListBoxUnselectAllCallback            ,+    noListBoxUnselectAllCallback            ,+    onListBoxUnselectAll                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype ListBox = ListBox (ForeignPtr ListBox)+foreign import ccall "gtk_list_box_get_type"+    c_gtk_list_box_get_type :: IO GType++type instance ParentTypes ListBox = ListBoxParentTypes+type ListBoxParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject ListBox where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_list_box_get_type+    ++class GObject o => ListBoxK o+instance (GObject o, IsDescendantOf ListBox o) => ListBoxK o++toListBox :: ListBoxK o => o -> IO ListBox+toListBox = unsafeCastTo ListBox++noListBox :: Maybe ListBox+noListBox = Nothing++-- signal ListBox::activate-cursor-row+type ListBoxActivateCursorRowCallback =+    IO ()++noListBoxActivateCursorRowCallback :: Maybe ListBoxActivateCursorRowCallback+noListBoxActivateCursorRowCallback = Nothing++type ListBoxActivateCursorRowCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxActivateCursorRowCallback :: ListBoxActivateCursorRowCallbackC -> IO (FunPtr ListBoxActivateCursorRowCallbackC)++listBoxActivateCursorRowClosure :: ListBoxActivateCursorRowCallback -> IO Closure+listBoxActivateCursorRowClosure cb = newCClosure =<< mkListBoxActivateCursorRowCallback wrapped+    where wrapped = listBoxActivateCursorRowCallbackWrapper cb++listBoxActivateCursorRowCallbackWrapper ::+    ListBoxActivateCursorRowCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxActivateCursorRowCallbackWrapper _cb _ _ = do+    _cb ++onListBoxActivateCursorRow :: (GObject a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId+onListBoxActivateCursorRow obj cb = liftIO $ connectListBoxActivateCursorRow obj cb SignalConnectBefore+afterListBoxActivateCursorRow :: (GObject a, MonadIO m) => a -> ListBoxActivateCursorRowCallback -> m SignalHandlerId+afterListBoxActivateCursorRow obj cb = connectListBoxActivateCursorRow obj cb SignalConnectAfter++connectListBoxActivateCursorRow :: (GObject a, MonadIO m) =>+                                   a -> ListBoxActivateCursorRowCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxActivateCursorRow obj cb after = liftIO $ do+    cb' <- mkListBoxActivateCursorRowCallback (listBoxActivateCursorRowCallbackWrapper cb)+    connectSignalFunPtr obj "activate-cursor-row" cb' after++-- signal ListBox::move-cursor+type ListBoxMoveCursorCallback =+    MovementStep ->+    Int32 ->+    IO ()++noListBoxMoveCursorCallback :: Maybe ListBoxMoveCursorCallback+noListBoxMoveCursorCallback = Nothing++type ListBoxMoveCursorCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxMoveCursorCallback :: ListBoxMoveCursorCallbackC -> IO (FunPtr ListBoxMoveCursorCallbackC)++listBoxMoveCursorClosure :: ListBoxMoveCursorCallback -> IO Closure+listBoxMoveCursorClosure cb = newCClosure =<< mkListBoxMoveCursorCallback wrapped+    where wrapped = listBoxMoveCursorCallbackWrapper cb++listBoxMoveCursorCallbackWrapper ::+    ListBoxMoveCursorCallback ->+    Ptr () ->+    CUInt ->+    Int32 ->+    Ptr () ->+    IO ()+listBoxMoveCursorCallbackWrapper _cb _ object p0 _ = do+    let object' = (toEnum . fromIntegral) object+    _cb  object' p0++onListBoxMoveCursor :: (GObject a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId+onListBoxMoveCursor obj cb = liftIO $ connectListBoxMoveCursor obj cb SignalConnectBefore+afterListBoxMoveCursor :: (GObject a, MonadIO m) => a -> ListBoxMoveCursorCallback -> m SignalHandlerId+afterListBoxMoveCursor obj cb = connectListBoxMoveCursor obj cb SignalConnectAfter++connectListBoxMoveCursor :: (GObject a, MonadIO m) =>+                            a -> ListBoxMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxMoveCursor obj cb after = liftIO $ do+    cb' <- mkListBoxMoveCursorCallback (listBoxMoveCursorCallbackWrapper cb)+    connectSignalFunPtr obj "move-cursor" cb' after++-- signal ListBox::row-activated+type ListBoxRowActivatedCallback =+    ListBoxRow ->+    IO ()++noListBoxRowActivatedCallback :: Maybe ListBoxRowActivatedCallback+noListBoxRowActivatedCallback = Nothing++type ListBoxRowActivatedCallbackC =+    Ptr () ->                               -- object+    Ptr ListBoxRow ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxRowActivatedCallback :: ListBoxRowActivatedCallbackC -> IO (FunPtr ListBoxRowActivatedCallbackC)++listBoxRowActivatedClosure :: ListBoxRowActivatedCallback -> IO Closure+listBoxRowActivatedClosure cb = newCClosure =<< mkListBoxRowActivatedCallback wrapped+    where wrapped = listBoxRowActivatedCallbackWrapper cb++listBoxRowActivatedCallbackWrapper ::+    ListBoxRowActivatedCallback ->+    Ptr () ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()+listBoxRowActivatedCallbackWrapper _cb _ row _ = do+    row' <- (newObject ListBoxRow) row+    _cb  row'++onListBoxRowActivated :: (GObject a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId+onListBoxRowActivated obj cb = liftIO $ connectListBoxRowActivated obj cb SignalConnectBefore+afterListBoxRowActivated :: (GObject a, MonadIO m) => a -> ListBoxRowActivatedCallback -> m SignalHandlerId+afterListBoxRowActivated obj cb = connectListBoxRowActivated obj cb SignalConnectAfter++connectListBoxRowActivated :: (GObject a, MonadIO m) =>+                              a -> ListBoxRowActivatedCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxRowActivated obj cb after = liftIO $ do+    cb' <- mkListBoxRowActivatedCallback (listBoxRowActivatedCallbackWrapper cb)+    connectSignalFunPtr obj "row-activated" cb' after++-- signal ListBox::row-selected+type ListBoxRowSelectedCallback =+    Maybe ListBoxRow ->+    IO ()++noListBoxRowSelectedCallback :: Maybe ListBoxRowSelectedCallback+noListBoxRowSelectedCallback = Nothing++type ListBoxRowSelectedCallbackC =+    Ptr () ->                               -- object+    Ptr ListBoxRow ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxRowSelectedCallback :: ListBoxRowSelectedCallbackC -> IO (FunPtr ListBoxRowSelectedCallbackC)++listBoxRowSelectedClosure :: ListBoxRowSelectedCallback -> IO Closure+listBoxRowSelectedClosure cb = newCClosure =<< mkListBoxRowSelectedCallback wrapped+    where wrapped = listBoxRowSelectedCallbackWrapper cb++listBoxRowSelectedCallbackWrapper ::+    ListBoxRowSelectedCallback ->+    Ptr () ->+    Ptr ListBoxRow ->+    Ptr () ->+    IO ()+listBoxRowSelectedCallbackWrapper _cb _ row _ = do+    maybeRow <-+        if row == nullPtr+        then return Nothing+        else do+            row' <- (newObject ListBoxRow) row+            return $ Just row'+    _cb  maybeRow++onListBoxRowSelected :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId+onListBoxRowSelected obj cb = liftIO $ connectListBoxRowSelected obj cb SignalConnectBefore+afterListBoxRowSelected :: (GObject a, MonadIO m) => a -> ListBoxRowSelectedCallback -> m SignalHandlerId+afterListBoxRowSelected obj cb = connectListBoxRowSelected obj cb SignalConnectAfter++connectListBoxRowSelected :: (GObject a, MonadIO m) =>+                             a -> ListBoxRowSelectedCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxRowSelected obj cb after = liftIO $ do+    cb' <- mkListBoxRowSelectedCallback (listBoxRowSelectedCallbackWrapper cb)+    connectSignalFunPtr obj "row-selected" cb' after++-- signal ListBox::select-all+type ListBoxSelectAllCallback =+    IO ()++noListBoxSelectAllCallback :: Maybe ListBoxSelectAllCallback+noListBoxSelectAllCallback = Nothing++type ListBoxSelectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxSelectAllCallback :: ListBoxSelectAllCallbackC -> IO (FunPtr ListBoxSelectAllCallbackC)++listBoxSelectAllClosure :: ListBoxSelectAllCallback -> IO Closure+listBoxSelectAllClosure cb = newCClosure =<< mkListBoxSelectAllCallback wrapped+    where wrapped = listBoxSelectAllCallbackWrapper cb++listBoxSelectAllCallbackWrapper ::+    ListBoxSelectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxSelectAllCallbackWrapper _cb _ _ = do+    _cb ++onListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId+onListBoxSelectAll obj cb = liftIO $ connectListBoxSelectAll obj cb SignalConnectBefore+afterListBoxSelectAll :: (GObject a, MonadIO m) => a -> ListBoxSelectAllCallback -> m SignalHandlerId+afterListBoxSelectAll obj cb = connectListBoxSelectAll obj cb SignalConnectAfter++connectListBoxSelectAll :: (GObject a, MonadIO m) =>+                           a -> ListBoxSelectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxSelectAll obj cb after = liftIO $ do+    cb' <- mkListBoxSelectAllCallback (listBoxSelectAllCallbackWrapper cb)+    connectSignalFunPtr obj "select-all" cb' after++-- signal ListBox::selected-rows-changed+type ListBoxSelectedRowsChangedCallback =+    IO ()++noListBoxSelectedRowsChangedCallback :: Maybe ListBoxSelectedRowsChangedCallback+noListBoxSelectedRowsChangedCallback = Nothing++type ListBoxSelectedRowsChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxSelectedRowsChangedCallback :: ListBoxSelectedRowsChangedCallbackC -> IO (FunPtr ListBoxSelectedRowsChangedCallbackC)++listBoxSelectedRowsChangedClosure :: ListBoxSelectedRowsChangedCallback -> IO Closure+listBoxSelectedRowsChangedClosure cb = newCClosure =<< mkListBoxSelectedRowsChangedCallback wrapped+    where wrapped = listBoxSelectedRowsChangedCallbackWrapper cb++listBoxSelectedRowsChangedCallbackWrapper ::+    ListBoxSelectedRowsChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxSelectedRowsChangedCallbackWrapper _cb _ _ = do+    _cb ++onListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId+onListBoxSelectedRowsChanged obj cb = liftIO $ connectListBoxSelectedRowsChanged obj cb SignalConnectBefore+afterListBoxSelectedRowsChanged :: (GObject a, MonadIO m) => a -> ListBoxSelectedRowsChangedCallback -> m SignalHandlerId+afterListBoxSelectedRowsChanged obj cb = connectListBoxSelectedRowsChanged obj cb SignalConnectAfter++connectListBoxSelectedRowsChanged :: (GObject a, MonadIO m) =>+                                     a -> ListBoxSelectedRowsChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxSelectedRowsChanged obj cb after = liftIO $ do+    cb' <- mkListBoxSelectedRowsChangedCallback (listBoxSelectedRowsChangedCallbackWrapper cb)+    connectSignalFunPtr obj "selected-rows-changed" cb' after++-- signal ListBox::toggle-cursor-row+type ListBoxToggleCursorRowCallback =+    IO ()++noListBoxToggleCursorRowCallback :: Maybe ListBoxToggleCursorRowCallback+noListBoxToggleCursorRowCallback = Nothing++type ListBoxToggleCursorRowCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxToggleCursorRowCallback :: ListBoxToggleCursorRowCallbackC -> IO (FunPtr ListBoxToggleCursorRowCallbackC)++listBoxToggleCursorRowClosure :: ListBoxToggleCursorRowCallback -> IO Closure+listBoxToggleCursorRowClosure cb = newCClosure =<< mkListBoxToggleCursorRowCallback wrapped+    where wrapped = listBoxToggleCursorRowCallbackWrapper cb++listBoxToggleCursorRowCallbackWrapper ::+    ListBoxToggleCursorRowCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxToggleCursorRowCallbackWrapper _cb _ _ = do+    _cb ++onListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId+onListBoxToggleCursorRow obj cb = liftIO $ connectListBoxToggleCursorRow obj cb SignalConnectBefore+afterListBoxToggleCursorRow :: (GObject a, MonadIO m) => a -> ListBoxToggleCursorRowCallback -> m SignalHandlerId+afterListBoxToggleCursorRow obj cb = connectListBoxToggleCursorRow obj cb SignalConnectAfter++connectListBoxToggleCursorRow :: (GObject a, MonadIO m) =>+                                 a -> ListBoxToggleCursorRowCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxToggleCursorRow obj cb after = liftIO $ do+    cb' <- mkListBoxToggleCursorRowCallback (listBoxToggleCursorRowCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-cursor-row" cb' after++-- signal ListBox::unselect-all+type ListBoxUnselectAllCallback =+    IO ()++noListBoxUnselectAllCallback :: Maybe ListBoxUnselectAllCallback+noListBoxUnselectAllCallback = Nothing++type ListBoxUnselectAllCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxUnselectAllCallback :: ListBoxUnselectAllCallbackC -> IO (FunPtr ListBoxUnselectAllCallbackC)++listBoxUnselectAllClosure :: ListBoxUnselectAllCallback -> IO Closure+listBoxUnselectAllClosure cb = newCClosure =<< mkListBoxUnselectAllCallback wrapped+    where wrapped = listBoxUnselectAllCallbackWrapper cb++listBoxUnselectAllCallbackWrapper ::+    ListBoxUnselectAllCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxUnselectAllCallbackWrapper _cb _ _ = do+    _cb ++onListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId+onListBoxUnselectAll obj cb = liftIO $ connectListBoxUnselectAll obj cb SignalConnectBefore+afterListBoxUnselectAll :: (GObject a, MonadIO m) => a -> ListBoxUnselectAllCallback -> m SignalHandlerId+afterListBoxUnselectAll obj cb = connectListBoxUnselectAll obj cb SignalConnectAfter++connectListBoxUnselectAll :: (GObject a, MonadIO m) =>+                             a -> ListBoxUnselectAllCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxUnselectAll obj cb after = liftIO $ do+    cb' <- mkListBoxUnselectAllCallback (listBoxUnselectAllCallbackWrapper cb)+    connectSignalFunPtr obj "unselect-all" cb' after++-- VVV Prop "activate-on-single-click"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getListBoxActivateOnSingleClick :: (MonadIO m, ListBoxK o) => o -> m Bool+getListBoxActivateOnSingleClick obj = liftIO $ getObjectPropertyBool obj "activate-on-single-click"++setListBoxActivateOnSingleClick :: (MonadIO m, ListBoxK o) => o -> Bool -> m ()+setListBoxActivateOnSingleClick obj val = liftIO $ setObjectPropertyBool obj "activate-on-single-click" val++constructListBoxActivateOnSingleClick :: Bool -> IO ([Char], GValue)+constructListBoxActivateOnSingleClick val = constructObjectPropertyBool "activate-on-single-click" val++data ListBoxActivateOnSingleClickPropertyInfo+instance AttrInfo ListBoxActivateOnSingleClickPropertyInfo where+    type AttrAllowedOps ListBoxActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ListBoxActivateOnSingleClickPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ListBoxActivateOnSingleClickPropertyInfo = ListBoxK+    type AttrGetType ListBoxActivateOnSingleClickPropertyInfo = Bool+    type AttrLabel ListBoxActivateOnSingleClickPropertyInfo = "ListBox::activate-on-single-click"+    attrGet _ = getListBoxActivateOnSingleClick+    attrSet _ = setListBoxActivateOnSingleClick+    attrConstruct _ = constructListBoxActivateOnSingleClick++-- VVV Prop "selection-mode"+   -- Type: TInterface "Gtk" "SelectionMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getListBoxSelectionMode :: (MonadIO m, ListBoxK o) => o -> m SelectionMode+getListBoxSelectionMode obj = liftIO $ getObjectPropertyEnum obj "selection-mode"++setListBoxSelectionMode :: (MonadIO m, ListBoxK o) => o -> SelectionMode -> m ()+setListBoxSelectionMode obj val = liftIO $ setObjectPropertyEnum obj "selection-mode" val++constructListBoxSelectionMode :: SelectionMode -> IO ([Char], GValue)+constructListBoxSelectionMode val = constructObjectPropertyEnum "selection-mode" val++data ListBoxSelectionModePropertyInfo+instance AttrInfo ListBoxSelectionModePropertyInfo where+    type AttrAllowedOps ListBoxSelectionModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ListBoxSelectionModePropertyInfo = (~) SelectionMode+    type AttrBaseTypeConstraint ListBoxSelectionModePropertyInfo = ListBoxK+    type AttrGetType ListBoxSelectionModePropertyInfo = SelectionMode+    type AttrLabel ListBoxSelectionModePropertyInfo = "ListBox::selection-mode"+    attrGet _ = getListBoxSelectionMode+    attrSet _ = setListBoxSelectionMode+    attrConstruct _ = constructListBoxSelectionMode++type instance AttributeList ListBox = ListBoxAttributeList+type ListBoxAttributeList = ('[ '("activate-on-single-click", ListBoxActivateOnSingleClickPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selection-mode", ListBoxSelectionModePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data ListBoxActivateCursorRowSignalInfo+instance SignalInfo ListBoxActivateCursorRowSignalInfo where+    type HaskellCallbackType ListBoxActivateCursorRowSignalInfo = ListBoxActivateCursorRowCallback+    connectSignal _ = connectListBoxActivateCursorRow++data ListBoxMoveCursorSignalInfo+instance SignalInfo ListBoxMoveCursorSignalInfo where+    type HaskellCallbackType ListBoxMoveCursorSignalInfo = ListBoxMoveCursorCallback+    connectSignal _ = connectListBoxMoveCursor++data ListBoxRowActivatedSignalInfo+instance SignalInfo ListBoxRowActivatedSignalInfo where+    type HaskellCallbackType ListBoxRowActivatedSignalInfo = ListBoxRowActivatedCallback+    connectSignal _ = connectListBoxRowActivated++data ListBoxRowSelectedSignalInfo+instance SignalInfo ListBoxRowSelectedSignalInfo where+    type HaskellCallbackType ListBoxRowSelectedSignalInfo = ListBoxRowSelectedCallback+    connectSignal _ = connectListBoxRowSelected++data ListBoxSelectAllSignalInfo+instance SignalInfo ListBoxSelectAllSignalInfo where+    type HaskellCallbackType ListBoxSelectAllSignalInfo = ListBoxSelectAllCallback+    connectSignal _ = connectListBoxSelectAll++data ListBoxSelectedRowsChangedSignalInfo+instance SignalInfo ListBoxSelectedRowsChangedSignalInfo where+    type HaskellCallbackType ListBoxSelectedRowsChangedSignalInfo = ListBoxSelectedRowsChangedCallback+    connectSignal _ = connectListBoxSelectedRowsChanged++data ListBoxToggleCursorRowSignalInfo+instance SignalInfo ListBoxToggleCursorRowSignalInfo where+    type HaskellCallbackType ListBoxToggleCursorRowSignalInfo = ListBoxToggleCursorRowCallback+    connectSignal _ = connectListBoxToggleCursorRow++data ListBoxUnselectAllSignalInfo+instance SignalInfo ListBoxUnselectAllSignalInfo where+    type HaskellCallbackType ListBoxUnselectAllSignalInfo = ListBoxUnselectAllCallback+    connectSignal _ = connectListBoxUnselectAll++type instance SignalList ListBox = ListBoxSignalList+type ListBoxSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-cursor-row", ListBoxActivateCursorRowSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-cursor", ListBoxMoveCursorSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("row-activated", ListBoxRowActivatedSignalInfo), '("row-selected", ListBoxRowSelectedSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select-all", ListBoxSelectAllSignalInfo), '("selected-rows-changed", ListBoxSelectedRowsChangedSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-cursor-row", ListBoxToggleCursorRowSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("unselect-all", ListBoxUnselectAllSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ListBox::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ListBox"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_new" gtk_list_box_new :: +    IO (Ptr ListBox)+++listBoxNew ::+    (MonadIO m) =>+    m ListBox+listBoxNew  = liftIO $ do+    result <- gtk_list_box_new+    checkUnexpectedReturnNULL "gtk_list_box_new" result+    result' <- (newObject ListBox) result+    return result'++-- method ListBox::bind_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "create_widget_func", argType = TInterface "Gtk" "ListBoxCreateWidgetFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, 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 "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "ListModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "create_widget_func", argType = TInterface "Gtk" "ListBoxCreateWidgetFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_bind_model" gtk_list_box_bind_model :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr Gio.ListModel ->                    -- model : TInterface "Gio" "ListModel"+    FunPtr ListBoxCreateWidgetFuncC ->      -- create_widget_func : TInterface "Gtk" "ListBoxCreateWidgetFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- user_data_free_func : TInterface "GLib" "DestroyNotify"+    IO ()+++listBoxBindModel ::+    (MonadIO m, ListBoxK a, Gio.ListModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    Maybe (ListBoxCreateWidgetFunc) ->      -- create_widget_func+    m ()+listBoxBindModel _obj model create_widget_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    maybeCreate_widget_func <- case create_widget_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCreate_widget_func -> do+            jCreate_widget_func' <- mkListBoxCreateWidgetFunc (listBoxCreateWidgetFuncWrapper Nothing jCreate_widget_func)+            return jCreate_widget_func'+    let user_data = castFunPtrToPtr maybeCreate_widget_func+    let user_data_free_func = safeFreeFunPtrPtr+    gtk_list_box_bind_model _obj' maybeModel maybeCreate_widget_func user_data user_data_free_func+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    return ()++-- method ListBox::drag_highlight_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_drag_highlight_row" gtk_list_box_drag_highlight_row :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr ListBoxRow ->                       -- row : TInterface "Gtk" "ListBoxRow"+    IO ()+++listBoxDragHighlightRow ::+    (MonadIO m, ListBoxK a, ListBoxRowK b) =>+    a ->                                    -- _obj+    b ->                                    -- row+    m ()+listBoxDragHighlightRow _obj row = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let row' = unsafeManagedPtrCastPtr row+    gtk_list_box_drag_highlight_row _obj' row'+    touchManagedPtr _obj+    touchManagedPtr row+    return ()++-- method ListBox::drag_unhighlight_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_drag_unhighlight_row" gtk_list_box_drag_unhighlight_row :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxDragUnhighlightRow ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxDragUnhighlightRow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_drag_unhighlight_row _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::get_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_activate_on_single_click" gtk_list_box_get_activate_on_single_click :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO CInt+++listBoxGetActivateOnSingleClick ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m Bool+listBoxGetActivateOnSingleClick _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_activate_on_single_click _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ListBox::get_adjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_adjustment" gtk_list_box_get_adjustment :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO (Ptr Adjustment)+++listBoxGetAdjustment ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m Adjustment+listBoxGetAdjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_adjustment _obj'+    checkUnexpectedReturnNULL "gtk_list_box_get_adjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method ListBox::get_row_at_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", 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 "Gtk" "ListBox", 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 : TInterface "Gtk" "ListBoxRow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_row_at_index" gtk_list_box_get_row_at_index :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Int32 ->                                -- index_ : TBasicType TInt32+    IO (Ptr ListBoxRow)+++listBoxGetRowAtIndex ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index_+    m ListBoxRow+listBoxGetRowAtIndex _obj index_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_row_at_index _obj' index_+    checkUnexpectedReturnNULL "gtk_list_box_get_row_at_index" result+    result' <- (newObject ListBoxRow) result+    touchManagedPtr _obj+    return result'++-- method ListBox::get_row_at_y+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ListBoxRow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_row_at_y" gtk_list_box_get_row_at_y :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Int32 ->                                -- y : TBasicType TInt32+    IO (Ptr ListBoxRow)+++listBoxGetRowAtY ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- y+    m ListBoxRow+listBoxGetRowAtY _obj y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_row_at_y _obj' y+    checkUnexpectedReturnNULL "gtk_list_box_get_row_at_y" result+    result' <- (newObject ListBoxRow) result+    touchManagedPtr _obj+    return result'++-- method ListBox::get_selected_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ListBoxRow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_selected_row" gtk_list_box_get_selected_row :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO (Ptr ListBoxRow)+++listBoxGetSelectedRow ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ListBoxRow+listBoxGetSelectedRow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_selected_row _obj'+    checkUnexpectedReturnNULL "gtk_list_box_get_selected_row" result+    result' <- (newObject ListBoxRow) result+    touchManagedPtr _obj+    return result'++-- method ListBox::get_selected_rows+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "ListBoxRow")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_selected_rows" gtk_list_box_get_selected_rows :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO (Ptr (GList (Ptr ListBoxRow)))+++listBoxGetSelectedRows ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m [ListBoxRow]+listBoxGetSelectedRows _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_selected_rows _obj'+    checkUnexpectedReturnNULL "gtk_list_box_get_selected_rows" result+    result' <- unpackGList result+    result'' <- mapM (newObject ListBoxRow) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method ListBox::get_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SelectionMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_get_selection_mode" gtk_list_box_get_selection_mode :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO CUInt+++listBoxGetSelectionMode ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m SelectionMode+listBoxGetSelectionMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_get_selection_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ListBox::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_list_box_insert" gtk_list_box_insert :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++listBoxInsert ::+    (MonadIO m, ListBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+listBoxInsert _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_list_box_insert _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ListBox::invalidate_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_invalidate_filter" gtk_list_box_invalidate_filter :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxInvalidateFilter ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxInvalidateFilter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_invalidate_filter _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::invalidate_headers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_invalidate_headers" gtk_list_box_invalidate_headers :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxInvalidateHeaders ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxInvalidateHeaders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_invalidate_headers _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::invalidate_sort+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_invalidate_sort" gtk_list_box_invalidate_sort :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxInvalidateSort ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxInvalidateSort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_invalidate_sort _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::prepend+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_prepend" gtk_list_box_prepend :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++listBoxPrepend ::+    (MonadIO m, ListBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+listBoxPrepend _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_list_box_prepend _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method ListBox::select_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_select_all" gtk_list_box_select_all :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxSelectAll ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxSelectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_select_all _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::select_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_select_row" gtk_list_box_select_row :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr ListBoxRow ->                       -- row : TInterface "Gtk" "ListBoxRow"+    IO ()+++listBoxSelectRow ::+    (MonadIO m, ListBoxK a, ListBoxRowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- row+    m ()+listBoxSelectRow _obj row = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeRow <- case row of+        Nothing -> return nullPtr+        Just jRow -> do+            let jRow' = unsafeManagedPtrCastPtr jRow+            return jRow'+    gtk_list_box_select_row _obj' maybeRow+    touchManagedPtr _obj+    whenJust row touchManagedPtr+    return ()++-- method ListBox::selected_foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "ListBoxForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, 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 "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "ListBoxForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_selected_foreach" gtk_list_box_selected_foreach :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    FunPtr ListBoxForeachFuncC ->           -- func : TInterface "Gtk" "ListBoxForeachFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++listBoxSelectedForeach ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    ListBoxForeachFunc ->                   -- func+    m ()+listBoxSelectedForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkListBoxForeachFunc (listBoxForeachFuncWrapper Nothing func)+    let data_ = nullPtr+    gtk_list_box_selected_foreach _obj' func' data_+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method ListBox::set_activate_on_single_click+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "single", 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 "gtk_list_box_set_activate_on_single_click" gtk_list_box_set_activate_on_single_click :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    CInt ->                                 -- single : TBasicType TBoolean+    IO ()+++listBoxSetActivateOnSingleClick ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- single+    m ()+listBoxSetActivateOnSingleClick _obj single = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let single' = (fromIntegral . fromEnum) single+    gtk_list_box_set_activate_on_single_click _obj' single'+    touchManagedPtr _obj+    return ()++-- method ListBox::set_adjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_adjustment" gtk_list_box_set_adjustment :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++listBoxSetAdjustment ::+    (MonadIO m, ListBoxK a, AdjustmentK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- adjustment+    m ()+listBoxSetAdjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAdjustment <- case adjustment of+        Nothing -> return nullPtr+        Just jAdjustment -> do+            let jAdjustment' = unsafeManagedPtrCastPtr jAdjustment+            return jAdjustment'+    gtk_list_box_set_adjustment _obj' maybeAdjustment+    touchManagedPtr _obj+    whenJust adjustment touchManagedPtr+    return ()++-- method ListBox::set_filter_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_func", argType = TInterface "Gtk" "ListBoxFilterFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filter_func", argType = TInterface "Gtk" "ListBoxFilterFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_filter_func" gtk_list_box_set_filter_func :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    FunPtr ListBoxFilterFuncC ->            -- filter_func : TInterface "Gtk" "ListBoxFilterFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++listBoxSetFilterFunc ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Maybe (ListBoxFilterFunc) ->            -- filter_func+    m ()+listBoxSetFilterFunc _obj filter_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter_func <- case filter_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFilter_func -> do+            jFilter_func' <- mkListBoxFilterFunc (listBoxFilterFuncWrapper Nothing jFilter_func)+            return jFilter_func'+    let user_data = castFunPtrToPtr maybeFilter_func+    let destroy = safeFreeFunPtrPtr+    gtk_list_box_set_filter_func _obj' maybeFilter_func user_data destroy+    touchManagedPtr _obj+    return ()++-- method ListBox::set_header_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "update_header", argType = TInterface "Gtk" "ListBoxUpdateHeaderFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "update_header", argType = TInterface "Gtk" "ListBoxUpdateHeaderFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_header_func" gtk_list_box_set_header_func :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    FunPtr ListBoxUpdateHeaderFuncC ->      -- update_header : TInterface "Gtk" "ListBoxUpdateHeaderFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++listBoxSetHeaderFunc ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Maybe (ListBoxUpdateHeaderFunc) ->      -- update_header+    m ()+listBoxSetHeaderFunc _obj update_header = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeUpdate_header <- case update_header of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jUpdate_header -> do+            jUpdate_header' <- mkListBoxUpdateHeaderFunc (listBoxUpdateHeaderFuncWrapper Nothing jUpdate_header)+            return jUpdate_header'+    let user_data = castFunPtrToPtr maybeUpdate_header+    let destroy = safeFreeFunPtrPtr+    gtk_list_box_set_header_func _obj' maybeUpdate_header user_data destroy+    touchManagedPtr _obj+    return ()++-- method ListBox::set_placeholder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "placeholder", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "placeholder", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_placeholder" gtk_list_box_set_placeholder :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr Widget ->                           -- placeholder : TInterface "Gtk" "Widget"+    IO ()+++listBoxSetPlaceholder ::+    (MonadIO m, ListBoxK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- placeholder+    m ()+listBoxSetPlaceholder _obj placeholder = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePlaceholder <- case placeholder of+        Nothing -> return nullPtr+        Just jPlaceholder -> do+            let jPlaceholder' = unsafeManagedPtrCastPtr jPlaceholder+            return jPlaceholder'+    gtk_list_box_set_placeholder _obj' maybePlaceholder+    touchManagedPtr _obj+    whenJust placeholder touchManagedPtr+    return ()++-- method ListBox::set_selection_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Gtk" "SelectionMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_selection_mode" gtk_list_box_set_selection_mode :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    CUInt ->                                -- mode : TInterface "Gtk" "SelectionMode"+    IO ()+++listBoxSetSelectionMode ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    SelectionMode ->                        -- mode+    m ()+listBoxSetSelectionMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_list_box_set_selection_mode _obj' mode'+    touchManagedPtr _obj+    return ()++-- method ListBox::set_sort_func+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "ListBoxSortFunc", direction = DirectionIn, mayBeNull = True, 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", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sort_func", argType = TInterface "Gtk" "ListBoxSortFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_set_sort_func" gtk_list_box_set_sort_func :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    FunPtr ListBoxSortFuncC ->              -- sort_func : TInterface "Gtk" "ListBoxSortFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++listBoxSetSortFunc ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    Maybe (ListBoxSortFunc) ->              -- sort_func+    m ()+listBoxSetSortFunc _obj sort_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSort_func <- case sort_func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jSort_func -> do+            jSort_func' <- mkListBoxSortFunc (listBoxSortFuncWrapper Nothing jSort_func)+            return jSort_func'+    let user_data = castFunPtrToPtr maybeSort_func+    let destroy = safeFreeFunPtrPtr+    gtk_list_box_set_sort_func _obj' maybeSort_func user_data destroy+    touchManagedPtr _obj+    return ()++-- method ListBox::unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_unselect_all" gtk_list_box_unselect_all :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    IO ()+++listBoxUnselectAll ::+    (MonadIO m, ListBoxK a) =>+    a ->                                    -- _obj+    m ()+listBoxUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method ListBox::unselect_row+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBox", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "row", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_unselect_row" gtk_list_box_unselect_row :: +    Ptr ListBox ->                          -- _obj : TInterface "Gtk" "ListBox"+    Ptr ListBoxRow ->                       -- row : TInterface "Gtk" "ListBoxRow"+    IO ()+++listBoxUnselectRow ::+    (MonadIO m, ListBoxK a, ListBoxRowK b) =>+    a ->                                    -- _obj+    b ->                                    -- row+    m ()+listBoxUnselectRow _obj row = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let row' = unsafeManagedPtrCastPtr row+    gtk_list_box_unselect_row _obj' row'+    touchManagedPtr _obj+    touchManagedPtr row+    return ()++
+ GI/Gtk/Objects/ListBox.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gtk.Objects.ListBox where++import Prelude ()+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 ListBox = ListBox (ForeignPtr ListBox)+instance GObject ListBox where+class GObject o => ListBoxK o+instance (GObject o, IsDescendantOf ListBox o) => ListBoxK o+data ListBoxActivateOnSingleClickPropertyInfo+data ListBoxSelectionModePropertyInfo+data ListBoxActivateCursorRowSignalInfo+data ListBoxMoveCursorSignalInfo+data ListBoxRowActivatedSignalInfo+data ListBoxRowSelectedSignalInfo+data ListBoxSelectAllSignalInfo+data ListBoxSelectedRowsChangedSignalInfo+data ListBoxToggleCursorRowSignalInfo+data ListBoxUnselectAllSignalInfo
+ GI/Gtk/Objects/ListBoxAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ListBoxAccessible+    ( ++-- * Exported types+    ListBoxAccessible(..)                   ,+    ListBoxAccessibleK                      ,+    toListBoxAccessible                     ,+    noListBoxAccessible                     ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ListBoxAccessible = ListBoxAccessible (ForeignPtr ListBoxAccessible)+foreign import ccall "gtk_list_box_accessible_get_type"+    c_gtk_list_box_accessible_get_type :: IO GType++type instance ParentTypes ListBoxAccessible = ListBoxAccessibleParentTypes+type ListBoxAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject ListBoxAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_list_box_accessible_get_type+    ++class GObject o => ListBoxAccessibleK o+instance (GObject o, IsDescendantOf ListBoxAccessible o) => ListBoxAccessibleK o++toListBoxAccessible :: ListBoxAccessibleK o => o -> IO ListBoxAccessible+toListBoxAccessible = unsafeCastTo ListBoxAccessible++noListBoxAccessible :: Maybe ListBoxAccessible+noListBoxAccessible = Nothing++type instance AttributeList ListBoxAccessible = ListBoxAccessibleAttributeList+type ListBoxAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ListBoxAccessible = ListBoxAccessibleSignalList+type ListBoxAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ListBoxAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ListBoxAccessible where++import Prelude ()+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 ListBoxAccessible = ListBoxAccessible (ForeignPtr ListBoxAccessible)+instance GObject ListBoxAccessible where+class GObject o => ListBoxAccessibleK o+instance (GObject o, IsDescendantOf ListBoxAccessible o) => ListBoxAccessibleK o
+ GI/Gtk/Objects/ListBoxRow.hs view
@@ -0,0 +1,482 @@++{- |+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.Gtk.Objects.ListBoxRow+    ( ++-- * Exported types+    ListBoxRow(..)                          ,+    ListBoxRowK                             ,+    toListBoxRow                            ,+    noListBoxRow                            ,+++ -- * Methods+-- ** listBoxRowChanged+    listBoxRowChanged                       ,+++-- ** listBoxRowGetActivatable+    listBoxRowGetActivatable                ,+++-- ** listBoxRowGetHeader+    listBoxRowGetHeader                     ,+++-- ** listBoxRowGetIndex+    listBoxRowGetIndex                      ,+++-- ** listBoxRowGetSelectable+    listBoxRowGetSelectable                 ,+++-- ** listBoxRowIsSelected+    listBoxRowIsSelected                    ,+++-- ** listBoxRowNew+    listBoxRowNew                           ,+++-- ** listBoxRowSetActivatable+    listBoxRowSetActivatable                ,+++-- ** listBoxRowSetHeader+    listBoxRowSetHeader                     ,+++-- ** listBoxRowSetSelectable+    listBoxRowSetSelectable                 ,+++++ -- * Properties+-- ** Activatable+    ListBoxRowActivatablePropertyInfo       ,+    constructListBoxRowActivatable          ,+    getListBoxRowActivatable                ,+    setListBoxRowActivatable                ,+++-- ** Selectable+    ListBoxRowSelectablePropertyInfo        ,+    constructListBoxRowSelectable           ,+    getListBoxRowSelectable                 ,+    setListBoxRowSelectable                 ,+++++ -- * Signals+-- ** Activate+    ListBoxRowActivateCallback              ,+    ListBoxRowActivateCallbackC             ,+    ListBoxRowActivateSignalInfo            ,+    afterListBoxRowActivate                 ,+    listBoxRowActivateCallbackWrapper       ,+    listBoxRowActivateClosure               ,+    mkListBoxRowActivateCallback            ,+    noListBoxRowActivateCallback            ,+    onListBoxRowActivate                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ListBoxRow = ListBoxRow (ForeignPtr ListBoxRow)+foreign import ccall "gtk_list_box_row_get_type"+    c_gtk_list_box_row_get_type :: IO GType++type instance ParentTypes ListBoxRow = ListBoxRowParentTypes+type ListBoxRowParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject ListBoxRow where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_list_box_row_get_type+    ++class GObject o => ListBoxRowK o+instance (GObject o, IsDescendantOf ListBoxRow o) => ListBoxRowK o++toListBoxRow :: ListBoxRowK o => o -> IO ListBoxRow+toListBoxRow = unsafeCastTo ListBoxRow++noListBoxRow :: Maybe ListBoxRow+noListBoxRow = Nothing++-- signal ListBoxRow::activate+type ListBoxRowActivateCallback =+    IO ()++noListBoxRowActivateCallback :: Maybe ListBoxRowActivateCallback+noListBoxRowActivateCallback = Nothing++type ListBoxRowActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkListBoxRowActivateCallback :: ListBoxRowActivateCallbackC -> IO (FunPtr ListBoxRowActivateCallbackC)++listBoxRowActivateClosure :: ListBoxRowActivateCallback -> IO Closure+listBoxRowActivateClosure cb = newCClosure =<< mkListBoxRowActivateCallback wrapped+    where wrapped = listBoxRowActivateCallbackWrapper cb++listBoxRowActivateCallbackWrapper ::+    ListBoxRowActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+listBoxRowActivateCallbackWrapper _cb _ _ = do+    _cb ++onListBoxRowActivate :: (GObject a, MonadIO m) => a -> ListBoxRowActivateCallback -> m SignalHandlerId+onListBoxRowActivate obj cb = liftIO $ connectListBoxRowActivate obj cb SignalConnectBefore+afterListBoxRowActivate :: (GObject a, MonadIO m) => a -> ListBoxRowActivateCallback -> m SignalHandlerId+afterListBoxRowActivate obj cb = connectListBoxRowActivate obj cb SignalConnectAfter++connectListBoxRowActivate :: (GObject a, MonadIO m) =>+                             a -> ListBoxRowActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectListBoxRowActivate obj cb after = liftIO $ do+    cb' <- mkListBoxRowActivateCallback (listBoxRowActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- VVV Prop "activatable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getListBoxRowActivatable :: (MonadIO m, ListBoxRowK o) => o -> m Bool+getListBoxRowActivatable obj = liftIO $ getObjectPropertyBool obj "activatable"++setListBoxRowActivatable :: (MonadIO m, ListBoxRowK o) => o -> Bool -> m ()+setListBoxRowActivatable obj val = liftIO $ setObjectPropertyBool obj "activatable" val++constructListBoxRowActivatable :: Bool -> IO ([Char], GValue)+constructListBoxRowActivatable val = constructObjectPropertyBool "activatable" val++data ListBoxRowActivatablePropertyInfo+instance AttrInfo ListBoxRowActivatablePropertyInfo where+    type AttrAllowedOps ListBoxRowActivatablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ListBoxRowActivatablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ListBoxRowActivatablePropertyInfo = ListBoxRowK+    type AttrGetType ListBoxRowActivatablePropertyInfo = Bool+    type AttrLabel ListBoxRowActivatablePropertyInfo = "ListBoxRow::activatable"+    attrGet _ = getListBoxRowActivatable+    attrSet _ = setListBoxRowActivatable+    attrConstruct _ = constructListBoxRowActivatable++-- VVV Prop "selectable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getListBoxRowSelectable :: (MonadIO m, ListBoxRowK o) => o -> m Bool+getListBoxRowSelectable obj = liftIO $ getObjectPropertyBool obj "selectable"++setListBoxRowSelectable :: (MonadIO m, ListBoxRowK o) => o -> Bool -> m ()+setListBoxRowSelectable obj val = liftIO $ setObjectPropertyBool obj "selectable" val++constructListBoxRowSelectable :: Bool -> IO ([Char], GValue)+constructListBoxRowSelectable val = constructObjectPropertyBool "selectable" val++data ListBoxRowSelectablePropertyInfo+instance AttrInfo ListBoxRowSelectablePropertyInfo where+    type AttrAllowedOps ListBoxRowSelectablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ListBoxRowSelectablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ListBoxRowSelectablePropertyInfo = ListBoxRowK+    type AttrGetType ListBoxRowSelectablePropertyInfo = Bool+    type AttrLabel ListBoxRowSelectablePropertyInfo = "ListBoxRow::selectable"+    attrGet _ = getListBoxRowSelectable+    attrSet _ = setListBoxRowSelectable+    attrConstruct _ = constructListBoxRowSelectable++type instance AttributeList ListBoxRow = ListBoxRowAttributeList+type ListBoxRowAttributeList = ('[ '("activatable", ListBoxRowActivatablePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("selectable", ListBoxRowSelectablePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data ListBoxRowActivateSignalInfo+instance SignalInfo ListBoxRowActivateSignalInfo where+    type HaskellCallbackType ListBoxRowActivateSignalInfo = ListBoxRowActivateCallback+    connectSignal _ = connectListBoxRowActivate++type instance SignalList ListBoxRow = ListBoxRowSignalList+type ListBoxRowSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ListBoxRowActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ListBoxRow::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ListBoxRow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_new" gtk_list_box_row_new :: +    IO (Ptr ListBoxRow)+++listBoxRowNew ::+    (MonadIO m) =>+    m ListBoxRow+listBoxRowNew  = liftIO $ do+    result <- gtk_list_box_row_new+    checkUnexpectedReturnNULL "gtk_list_box_row_new" result+    result' <- (newObject ListBoxRow) result+    return result'++-- method ListBoxRow::changed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_changed" gtk_list_box_row_changed :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO ()+++listBoxRowChanged ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m ()+listBoxRowChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_box_row_changed _obj'+    touchManagedPtr _obj+    return ()++-- method ListBoxRow::get_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_get_activatable" gtk_list_box_row_get_activatable :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO CInt+++listBoxRowGetActivatable ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m Bool+listBoxRowGetActivatable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_row_get_activatable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ListBoxRow::get_header+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_get_header" gtk_list_box_row_get_header :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO (Ptr Widget)+++listBoxRowGetHeader ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m Widget+listBoxRowGetHeader _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_row_get_header _obj'+    checkUnexpectedReturnNULL "gtk_list_box_row_get_header" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method ListBoxRow::get_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_get_index" gtk_list_box_row_get_index :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO Int32+++listBoxRowGetIndex ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m Int32+listBoxRowGetIndex _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_row_get_index _obj'+    touchManagedPtr _obj+    return result++-- method ListBoxRow::get_selectable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_get_selectable" gtk_list_box_row_get_selectable :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO CInt+++listBoxRowGetSelectable ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m Bool+listBoxRowGetSelectable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_row_get_selectable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ListBoxRow::is_selected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_is_selected" gtk_list_box_row_is_selected :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    IO CInt+++listBoxRowIsSelected ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    m Bool+listBoxRowIsSelected _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_list_box_row_is_selected _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ListBoxRow::set_activatable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activatable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activatable", 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 "gtk_list_box_row_set_activatable" gtk_list_box_row_set_activatable :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    CInt ->                                 -- activatable : TBasicType TBoolean+    IO ()+++listBoxRowSetActivatable ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- activatable+    m ()+listBoxRowSetActivatable _obj activatable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let activatable' = (fromIntegral . fromEnum) activatable+    gtk_list_box_row_set_activatable _obj' activatable'+    touchManagedPtr _obj+    return ()++-- method ListBoxRow::set_header+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "header", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_box_row_set_header" gtk_list_box_row_set_header :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    Ptr Widget ->                           -- header : TInterface "Gtk" "Widget"+    IO ()+++listBoxRowSetHeader ::+    (MonadIO m, ListBoxRowK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- header+    m ()+listBoxRowSetHeader _obj header = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeHeader <- case header of+        Nothing -> return nullPtr+        Just jHeader -> do+            let jHeader' = unsafeManagedPtrCastPtr jHeader+            return jHeader'+    gtk_list_box_row_set_header _obj' maybeHeader+    touchManagedPtr _obj+    whenJust header touchManagedPtr+    return ()++-- method ListBoxRow::set_selectable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selectable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListBoxRow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selectable", 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 "gtk_list_box_row_set_selectable" gtk_list_box_row_set_selectable :: +    Ptr ListBoxRow ->                       -- _obj : TInterface "Gtk" "ListBoxRow"+    CInt ->                                 -- selectable : TBasicType TBoolean+    IO ()+++listBoxRowSetSelectable ::+    (MonadIO m, ListBoxRowK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- selectable+    m ()+listBoxRowSetSelectable _obj selectable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let selectable' = (fromIntegral . fromEnum) selectable+    gtk_list_box_row_set_selectable _obj' selectable'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/ListBoxRow.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.ListBoxRow where++import Prelude ()+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 ListBoxRow = ListBoxRow (ForeignPtr ListBoxRow)+instance GObject ListBoxRow where+class GObject o => ListBoxRowK o+instance (GObject o, IsDescendantOf ListBoxRow o) => ListBoxRowK o+data ListBoxRowActivatablePropertyInfo+data ListBoxRowSelectablePropertyInfo+data ListBoxRowActivateSignalInfo
+ GI/Gtk/Objects/ListBoxRowAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ListBoxRowAccessible+    ( ++-- * Exported types+    ListBoxRowAccessible(..)                ,+    ListBoxRowAccessibleK                   ,+    toListBoxRowAccessible                  ,+    noListBoxRowAccessible                  ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ListBoxRowAccessible = ListBoxRowAccessible (ForeignPtr ListBoxRowAccessible)+foreign import ccall "gtk_list_box_row_accessible_get_type"+    c_gtk_list_box_row_accessible_get_type :: IO GType++type instance ParentTypes ListBoxRowAccessible = ListBoxRowAccessibleParentTypes+type ListBoxRowAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component]++instance GObject ListBoxRowAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_list_box_row_accessible_get_type+    ++class GObject o => ListBoxRowAccessibleK o+instance (GObject o, IsDescendantOf ListBoxRowAccessible o) => ListBoxRowAccessibleK o++toListBoxRowAccessible :: ListBoxRowAccessibleK o => o -> IO ListBoxRowAccessible+toListBoxRowAccessible = unsafeCastTo ListBoxRowAccessible++noListBoxRowAccessible :: Maybe ListBoxRowAccessible+noListBoxRowAccessible = Nothing++type instance AttributeList ListBoxRowAccessible = ListBoxRowAccessibleAttributeList+type ListBoxRowAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ListBoxRowAccessible = ListBoxRowAccessibleSignalList+type ListBoxRowAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ListBoxRowAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ListBoxRowAccessible where++import Prelude ()+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 ListBoxRowAccessible = ListBoxRowAccessible (ForeignPtr ListBoxRowAccessible)+instance GObject ListBoxRowAccessible where+class GObject o => ListBoxRowAccessibleK o+instance (GObject o, IsDescendantOf ListBoxRowAccessible o) => ListBoxRowAccessibleK o
+ GI/Gtk/Objects/ListStore.hs view
@@ -0,0 +1,675 @@++{- |+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.Gtk.Objects.ListStore+    ( ++-- * Exported types+    ListStore(..)                           ,+    ListStoreK                              ,+    toListStore                             ,+    noListStore                             ,+++ -- * Methods+-- ** listStoreAppend+    listStoreAppend                         ,+++-- ** listStoreClear+    listStoreClear                          ,+++-- ** listStoreInsert+    listStoreInsert                         ,+++-- ** listStoreInsertAfter+    listStoreInsertAfter                    ,+++-- ** listStoreInsertBefore+    listStoreInsertBefore                   ,+++-- ** listStoreInsertWithValuesv+    listStoreInsertWithValuesv              ,+++-- ** listStoreIterIsValid+    listStoreIterIsValid                    ,+++-- ** listStoreMoveAfter+    listStoreMoveAfter                      ,+++-- ** listStoreMoveBefore+    listStoreMoveBefore                     ,+++-- ** listStoreNew+    listStoreNew                            ,+++-- ** listStorePrepend+    listStorePrepend                        ,+++-- ** listStoreRemove+    listStoreRemove                         ,+++-- ** listStoreReorder+    listStoreReorder                        ,+++-- ** listStoreSet+    listStoreSet                            ,+++-- ** listStoreSetColumnTypes+    listStoreSetColumnTypes                 ,+++-- ** listStoreSetValue+    listStoreSetValue                       ,+++-- ** listStoreSwap+    listStoreSwap                           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype ListStore = ListStore (ForeignPtr ListStore)+foreign import ccall "gtk_list_store_get_type"+    c_gtk_list_store_get_type :: IO GType++type instance ParentTypes ListStore = ListStoreParentTypes+type ListStoreParentTypes = '[GObject.Object, Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable]++instance GObject ListStore where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_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++type instance AttributeList ListStore = ListStoreAttributeList+type ListStoreAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList ListStore = ListStoreSignalList+type ListStoreSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("row-changed", TreeModelRowChangedSignalInfo), '("row-deleted", TreeModelRowDeletedSignalInfo), '("row-has-child-toggled", TreeModelRowHasChildToggledSignalInfo), '("row-inserted", TreeModelRowInsertedSignalInfo), '("sort-column-changed", TreeSortableSortColumnChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ListStore::new+-- method type : Constructor+-- Args : [Arg {argName = "n_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "types", argType = TCArray False (-1) 0 (TBasicType TGType), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "types", argType = TCArray False (-1) 0 (TBasicType TGType), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ListStore"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_newv" gtk_list_store_newv :: +    Int32 ->                                -- n_columns : TBasicType TInt32+    Ptr CGType ->                           -- types : TCArray False (-1) 0 (TBasicType TGType)+    IO (Ptr ListStore)+++listStoreNew ::+    (MonadIO m) =>+    [GType] ->                              -- types+    m ListStore+listStoreNew types = liftIO $ do+    let n_columns = fromIntegral $ length types+    types' <- (packMapStorableArray gtypeToCGType) types+    result <- gtk_list_store_newv n_columns types'+    checkUnexpectedReturnNULL "gtk_list_store_newv" result+    result' <- (wrapObject ListStore) result+    freeMem types'+    return result'++-- method ListStore::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_append" gtk_list_store_append :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreAppend ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    m (TreeIter)+listStoreAppend _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    gtk_list_store_append _obj' iter+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    return iter'++-- method ListStore::clear+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_clear" gtk_list_store_clear :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    IO ()+++listStoreClear ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    m ()+listStoreClear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_list_store_clear _obj'+    touchManagedPtr _obj+    return ()++-- method ListStore::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, 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 "Gtk" "ListStore", 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 "gtk_list_store_insert" gtk_list_store_insert :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++listStoreInsert ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m (TreeIter)+listStoreInsert _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    gtk_list_store_insert _obj' iter position+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    return iter'++-- method ListStore::insert_after+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_insert_after" gtk_list_store_insert_after :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- sibling : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreInsertAfter ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- sibling+    m (TreeIter)+listStoreInsertAfter _obj sibling = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    maybeSibling <- case sibling of+        Nothing -> return nullPtr+        Just jSibling -> do+            let jSibling' = unsafeManagedPtrGetPtr jSibling+            return jSibling'+    gtk_list_store_insert_after _obj' iter maybeSibling+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    whenJust sibling touchManagedPtr+    return iter'++-- method ListStore::insert_before+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sibling", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_insert_before" gtk_list_store_insert_before :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- sibling : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreInsertBefore ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Maybe (TreeIter) ->                     -- sibling+    m (TreeIter)+listStoreInsertBefore _obj sibling = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    maybeSibling <- case sibling of+        Nothing -> return nullPtr+        Just jSibling -> do+            let jSibling' = unsafeManagedPtrGetPtr jSibling+            return jSibling'+    gtk_list_store_insert_before _obj' iter maybeSibling+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    whenJust sibling touchManagedPtr+    return iter'++-- method ListStore::insert_with_valuesv+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, 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 = "columns", argType = TCArray False (-1) 5 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "values", argType = TCArray False (-1) 5 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", 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 = "columns", argType = TCArray False (-1) 5 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "values", argType = TCArray False (-1) 5 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_insert_with_valuesv" gtk_list_store_insert_with_valuesv :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Int32 ->                                -- position : TBasicType TInt32+    Ptr Int32 ->                            -- columns : TCArray False (-1) 5 (TBasicType TInt32)+    Ptr GValue ->                           -- values : TCArray False (-1) 5 (TInterface "GObject" "Value")+    Int32 ->                                -- n_values : TBasicType TInt32+    IO ()+++listStoreInsertWithValuesv ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    [Int32] ->                              -- columns+    [GValue] ->                             -- values+    m (TreeIter)+listStoreInsertWithValuesv _obj position columns values = liftIO $ do+    let n_values = fromIntegral $ length values+    let columns_expected_length_ = fromIntegral $ length columns+    when (columns_expected_length_ /= n_values) $+        error "Gtk.listStoreInsertWithValuesv : length of 'columns' does not agree with that of 'values'."+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    columns' <- packStorableArray columns+    let values' = map unsafeManagedPtrGetPtr values+    values'' <- packBlockArray 24 values'+    gtk_list_store_insert_with_valuesv _obj' iter position columns' values'' n_values+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    mapM_ touchManagedPtr values+    freeMem columns'+    freeMem values''+    return iter'++-- method ListStore::iter_is_valid+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_iter_is_valid" gtk_list_store_iter_is_valid :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++listStoreIterIsValid ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m Bool+listStoreIterIsValid _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_list_store_iter_is_valid _obj' iter'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method ListStore::move_after+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_move_after" gtk_list_store_move_after :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- position : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreMoveAfter ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    Maybe (TreeIter) ->                     -- position+    m ()+listStoreMoveAfter _obj iter position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    maybePosition <- case position of+        Nothing -> return nullPtr+        Just jPosition -> do+            let jPosition' = unsafeManagedPtrGetPtr jPosition+            return jPosition'+    gtk_list_store_move_after _obj' iter' maybePosition+    touchManagedPtr _obj+    touchManagedPtr iter+    whenJust position touchManagedPtr+    return ()++-- method ListStore::move_before+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_move_before" gtk_list_store_move_before :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- position : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreMoveBefore ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    Maybe (TreeIter) ->                     -- position+    m ()+listStoreMoveBefore _obj iter position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    maybePosition <- case position of+        Nothing -> return nullPtr+        Just jPosition -> do+            let jPosition' = unsafeManagedPtrGetPtr jPosition+            return jPosition'+    gtk_list_store_move_before _obj' iter' maybePosition+    touchManagedPtr _obj+    touchManagedPtr iter+    whenJust position touchManagedPtr+    return ()++-- method ListStore::prepend+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_prepend" gtk_list_store_prepend :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO ()+++listStorePrepend ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    m (TreeIter)+listStorePrepend _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- callocBoxedBytes 32 :: IO (Ptr TreeIter)+    gtk_list_store_prepend _obj' iter+    iter' <- (wrapBoxed TreeIter) iter+    touchManagedPtr _obj+    return iter'++-- method ListStore::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_remove" gtk_list_store_remove :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    IO CInt+++listStoreRemove ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    m Bool+listStoreRemove _obj iter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    result <- gtk_list_store_remove _obj' iter'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr iter+    return result'++-- method ListStore::reorder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray True (-1) (-1) (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "new_order", argType = TCArray True (-1) (-1) (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 "gtk_list_store_reorder" gtk_list_store_reorder :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr Int32 ->                            -- new_order : TCArray True (-1) (-1) (TBasicType TInt32)+    IO ()+++listStoreReorder ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    [Int32] ->                              -- new_order+    m ()+listStoreReorder _obj new_order = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    new_order' <- packZeroTerminatedStorableArray new_order+    gtk_list_store_reorder _obj' new_order'+    touchManagedPtr _obj+    freeMem new_order'+    return ()++-- method ListStore::set_column_types+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "types", argType = TCArray False (-1) 1 (TBasicType TGType), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_columns", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "types", argType = TCArray False (-1) 1 (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 "gtk_list_store_set_column_types" gtk_list_store_set_column_types :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Int32 ->                                -- n_columns : TBasicType TInt32+    Ptr CGType ->                           -- types : TCArray False (-1) 1 (TBasicType TGType)+    IO ()+++listStoreSetColumnTypes ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    [GType] ->                              -- types+    m ()+listStoreSetColumnTypes _obj types = liftIO $ do+    let n_columns = fromIntegral $ length types+    let _obj' = unsafeManagedPtrCastPtr _obj+    types' <- (packMapStorableArray gtypeToCGType) types+    gtk_list_store_set_column_types _obj' n_columns types'+    touchManagedPtr _obj+    freeMem types'+    return ()++-- method ListStore::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "column", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_set_value" gtk_list_store_set_value :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Int32 ->                                -- column : TBasicType TInt32+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++listStoreSetValue ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    Int32 ->                                -- column+    GValue ->                               -- value+    m ()+listStoreSetValue _obj iter column value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    let value' = unsafeManagedPtrGetPtr value+    gtk_list_store_set_value _obj' iter' column value'+    touchManagedPtr _obj+    touchManagedPtr iter+    touchManagedPtr value+    return ()++-- method ListStore::set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TCArray False (-1) 4 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "values", argType = TCArray False (-1) 4 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "columns", argType = TCArray False (-1) 4 (TBasicType TInt32), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "values", argType = TCArray False (-1) 4 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_set_valuesv" gtk_list_store_set_valuesv :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- iter : TInterface "Gtk" "TreeIter"+    Ptr Int32 ->                            -- columns : TCArray False (-1) 4 (TBasicType TInt32)+    Ptr GValue ->                           -- values : TCArray False (-1) 4 (TInterface "GObject" "Value")+    Int32 ->                                -- n_values : TBasicType TInt32+    IO ()+++listStoreSet ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- iter+    [Int32] ->                              -- columns+    [GValue] ->                             -- values+    m ()+listStoreSet _obj iter columns values = liftIO $ do+    let n_values = fromIntegral $ length values+    let columns_expected_length_ = fromIntegral $ length columns+    when (columns_expected_length_ /= n_values) $+        error "Gtk.listStoreSet : length of 'columns' does not agree with that of 'values'."+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iter' = unsafeManagedPtrGetPtr iter+    columns' <- packStorableArray columns+    let values' = map unsafeManagedPtrGetPtr values+    values'' <- packBlockArray 24 values'+    gtk_list_store_set_valuesv _obj' iter' columns' values'' n_values+    touchManagedPtr _obj+    touchManagedPtr iter+    mapM_ touchManagedPtr values+    freeMem columns'+    freeMem values''+    return ()++-- method ListStore::swap+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "a", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "b", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ListStore", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "a", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "b", argType = TInterface "Gtk" "TreeIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_list_store_swap" gtk_list_store_swap :: +    Ptr ListStore ->                        -- _obj : TInterface "Gtk" "ListStore"+    Ptr TreeIter ->                         -- a : TInterface "Gtk" "TreeIter"+    Ptr TreeIter ->                         -- b : TInterface "Gtk" "TreeIter"+    IO ()+++listStoreSwap ::+    (MonadIO m, ListStoreK a) =>+    a ->                                    -- _obj+    TreeIter ->                             -- a+    TreeIter ->                             -- b+    m ()+listStoreSwap _obj a b = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let a' = unsafeManagedPtrGetPtr a+    let b' = unsafeManagedPtrGetPtr b+    gtk_list_store_swap _obj' a' b'+    touchManagedPtr _obj+    touchManagedPtr a+    touchManagedPtr b+    return ()++
+ GI/Gtk/Objects/ListStore.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.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
+ GI/Gtk/Objects/LockButton.hs view
@@ -0,0 +1,352 @@++{- |+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.Gtk.Objects.LockButton+    ( ++-- * Exported types+    LockButton(..)                          ,+    LockButtonK                             ,+    toLockButton                            ,+    noLockButton                            ,+++ -- * Methods+-- ** lockButtonGetPermission+    lockButtonGetPermission                 ,+++-- ** lockButtonNew+    lockButtonNew                           ,+++-- ** lockButtonSetPermission+    lockButtonSetPermission                 ,+++++ -- * Properties+-- ** Permission+    LockButtonPermissionPropertyInfo        ,+    constructLockButtonPermission           ,+    getLockButtonPermission                 ,+    setLockButtonPermission                 ,+++-- ** TextLock+    LockButtonTextLockPropertyInfo          ,+    constructLockButtonTextLock             ,+    getLockButtonTextLock                   ,+    setLockButtonTextLock                   ,+++-- ** TextUnlock+    LockButtonTextUnlockPropertyInfo        ,+    constructLockButtonTextUnlock           ,+    getLockButtonTextUnlock                 ,+    setLockButtonTextUnlock                 ,+++-- ** TooltipLock+    LockButtonTooltipLockPropertyInfo       ,+    constructLockButtonTooltipLock          ,+    getLockButtonTooltipLock                ,+    setLockButtonTooltipLock                ,+++-- ** TooltipNotAuthorized+    LockButtonTooltipNotAuthorizedPropertyInfo,+    constructLockButtonTooltipNotAuthorized ,+    getLockButtonTooltipNotAuthorized       ,+    setLockButtonTooltipNotAuthorized       ,+++-- ** TooltipUnlock+    LockButtonTooltipUnlockPropertyInfo     ,+    constructLockButtonTooltipUnlock        ,+    getLockButtonTooltipUnlock              ,+    setLockButtonTooltipUnlock              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype LockButton = LockButton (ForeignPtr LockButton)+foreign import ccall "gtk_lock_button_get_type"+    c_gtk_lock_button_get_type :: IO GType++type instance ParentTypes LockButton = LockButtonParentTypes+type LockButtonParentTypes = '[Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject LockButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_lock_button_get_type+    ++class GObject o => LockButtonK o+instance (GObject o, IsDescendantOf LockButton o) => LockButtonK o++toLockButton :: LockButtonK o => o -> IO LockButton+toLockButton = unsafeCastTo LockButton++noLockButton :: Maybe LockButton+noLockButton = Nothing++-- VVV Prop "permission"+   -- Type: TInterface "Gio" "Permission"+   -- Flags: [PropertyReadable,PropertyWritable]++getLockButtonPermission :: (MonadIO m, LockButtonK o) => o -> m Gio.Permission+getLockButtonPermission obj = liftIO $ getObjectPropertyObject obj "permission" Gio.Permission++setLockButtonPermission :: (MonadIO m, LockButtonK o, Gio.PermissionK a) => o -> a -> m ()+setLockButtonPermission obj val = liftIO $ setObjectPropertyObject obj "permission" val++constructLockButtonPermission :: (Gio.PermissionK a) => a -> IO ([Char], GValue)+constructLockButtonPermission val = constructObjectPropertyObject "permission" val++data LockButtonPermissionPropertyInfo+instance AttrInfo LockButtonPermissionPropertyInfo where+    type AttrAllowedOps LockButtonPermissionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonPermissionPropertyInfo = Gio.PermissionK+    type AttrBaseTypeConstraint LockButtonPermissionPropertyInfo = LockButtonK+    type AttrGetType LockButtonPermissionPropertyInfo = Gio.Permission+    type AttrLabel LockButtonPermissionPropertyInfo = "LockButton::permission"+    attrGet _ = getLockButtonPermission+    attrSet _ = setLockButtonPermission+    attrConstruct _ = constructLockButtonPermission++-- VVV Prop "text-lock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getLockButtonTextLock :: (MonadIO m, LockButtonK o) => o -> m T.Text+getLockButtonTextLock obj = liftIO $ getObjectPropertyString obj "text-lock"++setLockButtonTextLock :: (MonadIO m, LockButtonK o) => o -> T.Text -> m ()+setLockButtonTextLock obj val = liftIO $ setObjectPropertyString obj "text-lock" val++constructLockButtonTextLock :: T.Text -> IO ([Char], GValue)+constructLockButtonTextLock val = constructObjectPropertyString "text-lock" val++data LockButtonTextLockPropertyInfo+instance AttrInfo LockButtonTextLockPropertyInfo where+    type AttrAllowedOps LockButtonTextLockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonTextLockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LockButtonTextLockPropertyInfo = LockButtonK+    type AttrGetType LockButtonTextLockPropertyInfo = T.Text+    type AttrLabel LockButtonTextLockPropertyInfo = "LockButton::text-lock"+    attrGet _ = getLockButtonTextLock+    attrSet _ = setLockButtonTextLock+    attrConstruct _ = constructLockButtonTextLock++-- VVV Prop "text-unlock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getLockButtonTextUnlock :: (MonadIO m, LockButtonK o) => o -> m T.Text+getLockButtonTextUnlock obj = liftIO $ getObjectPropertyString obj "text-unlock"++setLockButtonTextUnlock :: (MonadIO m, LockButtonK o) => o -> T.Text -> m ()+setLockButtonTextUnlock obj val = liftIO $ setObjectPropertyString obj "text-unlock" val++constructLockButtonTextUnlock :: T.Text -> IO ([Char], GValue)+constructLockButtonTextUnlock val = constructObjectPropertyString "text-unlock" val++data LockButtonTextUnlockPropertyInfo+instance AttrInfo LockButtonTextUnlockPropertyInfo where+    type AttrAllowedOps LockButtonTextUnlockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonTextUnlockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LockButtonTextUnlockPropertyInfo = LockButtonK+    type AttrGetType LockButtonTextUnlockPropertyInfo = T.Text+    type AttrLabel LockButtonTextUnlockPropertyInfo = "LockButton::text-unlock"+    attrGet _ = getLockButtonTextUnlock+    attrSet _ = setLockButtonTextUnlock+    attrConstruct _ = constructLockButtonTextUnlock++-- VVV Prop "tooltip-lock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getLockButtonTooltipLock :: (MonadIO m, LockButtonK o) => o -> m T.Text+getLockButtonTooltipLock obj = liftIO $ getObjectPropertyString obj "tooltip-lock"++setLockButtonTooltipLock :: (MonadIO m, LockButtonK o) => o -> T.Text -> m ()+setLockButtonTooltipLock obj val = liftIO $ setObjectPropertyString obj "tooltip-lock" val++constructLockButtonTooltipLock :: T.Text -> IO ([Char], GValue)+constructLockButtonTooltipLock val = constructObjectPropertyString "tooltip-lock" val++data LockButtonTooltipLockPropertyInfo+instance AttrInfo LockButtonTooltipLockPropertyInfo where+    type AttrAllowedOps LockButtonTooltipLockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonTooltipLockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LockButtonTooltipLockPropertyInfo = LockButtonK+    type AttrGetType LockButtonTooltipLockPropertyInfo = T.Text+    type AttrLabel LockButtonTooltipLockPropertyInfo = "LockButton::tooltip-lock"+    attrGet _ = getLockButtonTooltipLock+    attrSet _ = setLockButtonTooltipLock+    attrConstruct _ = constructLockButtonTooltipLock++-- VVV Prop "tooltip-not-authorized"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getLockButtonTooltipNotAuthorized :: (MonadIO m, LockButtonK o) => o -> m T.Text+getLockButtonTooltipNotAuthorized obj = liftIO $ getObjectPropertyString obj "tooltip-not-authorized"++setLockButtonTooltipNotAuthorized :: (MonadIO m, LockButtonK o) => o -> T.Text -> m ()+setLockButtonTooltipNotAuthorized obj val = liftIO $ setObjectPropertyString obj "tooltip-not-authorized" val++constructLockButtonTooltipNotAuthorized :: T.Text -> IO ([Char], GValue)+constructLockButtonTooltipNotAuthorized val = constructObjectPropertyString "tooltip-not-authorized" val++data LockButtonTooltipNotAuthorizedPropertyInfo+instance AttrInfo LockButtonTooltipNotAuthorizedPropertyInfo where+    type AttrAllowedOps LockButtonTooltipNotAuthorizedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonTooltipNotAuthorizedPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LockButtonTooltipNotAuthorizedPropertyInfo = LockButtonK+    type AttrGetType LockButtonTooltipNotAuthorizedPropertyInfo = T.Text+    type AttrLabel LockButtonTooltipNotAuthorizedPropertyInfo = "LockButton::tooltip-not-authorized"+    attrGet _ = getLockButtonTooltipNotAuthorized+    attrSet _ = setLockButtonTooltipNotAuthorized+    attrConstruct _ = constructLockButtonTooltipNotAuthorized++-- VVV Prop "tooltip-unlock"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getLockButtonTooltipUnlock :: (MonadIO m, LockButtonK o) => o -> m T.Text+getLockButtonTooltipUnlock obj = liftIO $ getObjectPropertyString obj "tooltip-unlock"++setLockButtonTooltipUnlock :: (MonadIO m, LockButtonK o) => o -> T.Text -> m ()+setLockButtonTooltipUnlock obj val = liftIO $ setObjectPropertyString obj "tooltip-unlock" val++constructLockButtonTooltipUnlock :: T.Text -> IO ([Char], GValue)+constructLockButtonTooltipUnlock val = constructObjectPropertyString "tooltip-unlock" val++data LockButtonTooltipUnlockPropertyInfo+instance AttrInfo LockButtonTooltipUnlockPropertyInfo where+    type AttrAllowedOps LockButtonTooltipUnlockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint LockButtonTooltipUnlockPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint LockButtonTooltipUnlockPropertyInfo = LockButtonK+    type AttrGetType LockButtonTooltipUnlockPropertyInfo = T.Text+    type AttrLabel LockButtonTooltipUnlockPropertyInfo = "LockButton::tooltip-unlock"+    attrGet _ = getLockButtonTooltipUnlock+    attrSet _ = setLockButtonTooltipUnlock+    attrConstruct _ = constructLockButtonTooltipUnlock++type instance AttributeList LockButton = LockButtonAttributeList+type LockButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("permission", LockButtonPermissionPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("text-lock", LockButtonTextLockPropertyInfo), '("text-unlock", LockButtonTextUnlockPropertyInfo), '("tooltip-lock", LockButtonTooltipLockPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-not-authorized", LockButtonTooltipNotAuthorizedPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("tooltip-unlock", LockButtonTooltipUnlockPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++type instance SignalList LockButton = LockButtonSignalList+type LockButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method LockButton::new+-- method type : Constructor+-- Args : [Arg {argName = "permission", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "permission", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "LockButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_lock_button_new" gtk_lock_button_new :: +    Ptr Gio.Permission ->                   -- permission : TInterface "Gio" "Permission"+    IO (Ptr LockButton)+++lockButtonNew ::+    (MonadIO m, Gio.PermissionK a) =>+    Maybe (a) ->                            -- permission+    m LockButton+lockButtonNew permission = liftIO $ do+    maybePermission <- case permission of+        Nothing -> return nullPtr+        Just jPermission -> do+            let jPermission' = unsafeManagedPtrCastPtr jPermission+            return jPermission'+    result <- gtk_lock_button_new maybePermission+    checkUnexpectedReturnNULL "gtk_lock_button_new" result+    result' <- (newObject LockButton) result+    whenJust permission touchManagedPtr+    return result'++-- method LockButton::get_permission+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LockButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LockButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Permission"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_lock_button_get_permission" gtk_lock_button_get_permission :: +    Ptr LockButton ->                       -- _obj : TInterface "Gtk" "LockButton"+    IO (Ptr Gio.Permission)+++lockButtonGetPermission ::+    (MonadIO m, LockButtonK a) =>+    a ->                                    -- _obj+    m Gio.Permission+lockButtonGetPermission _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_lock_button_get_permission _obj'+    checkUnexpectedReturnNULL "gtk_lock_button_get_permission" result+    result' <- (newObject Gio.Permission) result+    touchManagedPtr _obj+    return result'++-- method LockButton::set_permission+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "LockButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "permission", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "LockButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "permission", argType = TInterface "Gio" "Permission", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_lock_button_set_permission" gtk_lock_button_set_permission :: +    Ptr LockButton ->                       -- _obj : TInterface "Gtk" "LockButton"+    Ptr Gio.Permission ->                   -- permission : TInterface "Gio" "Permission"+    IO ()+++lockButtonSetPermission ::+    (MonadIO m, LockButtonK a, Gio.PermissionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- permission+    m ()+lockButtonSetPermission _obj permission = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePermission <- case permission of+        Nothing -> return nullPtr+        Just jPermission -> do+            let jPermission' = unsafeManagedPtrCastPtr jPermission+            return jPermission'+    gtk_lock_button_set_permission _obj' maybePermission+    touchManagedPtr _obj+    whenJust permission touchManagedPtr+    return ()++
+ GI/Gtk/Objects/LockButton.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.LockButton where++import Prelude ()+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 LockButton = LockButton (ForeignPtr LockButton)+instance GObject LockButton where+class GObject o => LockButtonK o+instance (GObject o, IsDescendantOf LockButton o) => LockButtonK o+data LockButtonPermissionPropertyInfo+data LockButtonTextLockPropertyInfo+data LockButtonTextUnlockPropertyInfo+data LockButtonTooltipLockPropertyInfo+data LockButtonTooltipNotAuthorizedPropertyInfo+data LockButtonTooltipUnlockPropertyInfo
+ GI/Gtk/Objects/LockButtonAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.LockButtonAccessible+    ( ++-- * Exported types+    LockButtonAccessible(..)                ,+    LockButtonAccessibleK                   ,+    toLockButtonAccessible                  ,+    noLockButtonAccessible                  ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype LockButtonAccessible = LockButtonAccessible (ForeignPtr LockButtonAccessible)+foreign import ccall "gtk_lock_button_accessible_get_type"+    c_gtk_lock_button_accessible_get_type :: IO GType++type instance ParentTypes LockButtonAccessible = LockButtonAccessibleParentTypes+type LockButtonAccessibleParentTypes = '[ButtonAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Image]++instance GObject LockButtonAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_lock_button_accessible_get_type+    ++class GObject o => LockButtonAccessibleK o+instance (GObject o, IsDescendantOf LockButtonAccessible o) => LockButtonAccessibleK o++toLockButtonAccessible :: LockButtonAccessibleK o => o -> IO LockButtonAccessible+toLockButtonAccessible = unsafeCastTo LockButtonAccessible++noLockButtonAccessible :: Maybe LockButtonAccessible+noLockButtonAccessible = Nothing++type instance AttributeList LockButtonAccessible = LockButtonAccessibleAttributeList+type LockButtonAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList LockButtonAccessible = LockButtonAccessibleSignalList+type LockButtonAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/LockButtonAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.LockButtonAccessible where++import Prelude ()+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 LockButtonAccessible = LockButtonAccessible (ForeignPtr LockButtonAccessible)+instance GObject LockButtonAccessible where+class GObject o => LockButtonAccessibleK o+instance (GObject o, IsDescendantOf LockButtonAccessible o) => LockButtonAccessibleK o
+ GI/Gtk/Objects/Menu.hs view
@@ -0,0 +1,1288 @@++{- |+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.Gtk.Objects.Menu+    ( ++-- * Exported types+    Menu(..)                                ,+    MenuK                                   ,+    toMenu                                  ,+    noMenu                                  ,+++ -- * Methods+-- ** menuAttach+    menuAttach                              ,+++-- ** menuAttachToWidget+    menuAttachToWidget                      ,+++-- ** menuDetach+    menuDetach                              ,+++-- ** menuGetAccelGroup+    menuGetAccelGroup                       ,+++-- ** menuGetAccelPath+    menuGetAccelPath                        ,+++-- ** menuGetActive+    menuGetActive                           ,+++-- ** menuGetAttachWidget+    menuGetAttachWidget                     ,+++-- ** menuGetForAttachWidget+    menuGetForAttachWidget                  ,+++-- ** menuGetMonitor+    menuGetMonitor                          ,+++-- ** menuGetReserveToggleSize+    menuGetReserveToggleSize                ,+++-- ** menuGetTearoffState+    menuGetTearoffState                     ,+++-- ** menuGetTitle+    menuGetTitle                            ,+++-- ** menuNew+    menuNew                                 ,+++-- ** menuNewFromModel+    menuNewFromModel                        ,+++-- ** menuPopdown+    menuPopdown                             ,+++-- ** menuPopup+    menuPopup                               ,+++-- ** menuPopupForDevice+    menuPopupForDevice                      ,+++-- ** menuReorderChild+    menuReorderChild                        ,+++-- ** menuReposition+    menuReposition                          ,+++-- ** menuSetAccelGroup+    menuSetAccelGroup                       ,+++-- ** menuSetAccelPath+    menuSetAccelPath                        ,+++-- ** menuSetActive+    menuSetActive                           ,+++-- ** menuSetMonitor+    menuSetMonitor                          ,+++-- ** menuSetReserveToggleSize+    menuSetReserveToggleSize                ,+++-- ** menuSetScreen+    menuSetScreen                           ,+++-- ** menuSetTearoffState+    menuSetTearoffState                     ,+++-- ** menuSetTitle+    menuSetTitle                            ,+++++ -- * Properties+-- ** AccelGroup+    MenuAccelGroupPropertyInfo              ,+    constructMenuAccelGroup                 ,+    getMenuAccelGroup                       ,+    setMenuAccelGroup                       ,+++-- ** AccelPath+    MenuAccelPathPropertyInfo               ,+    constructMenuAccelPath                  ,+    getMenuAccelPath                        ,+    setMenuAccelPath                        ,+++-- ** Active+    MenuActivePropertyInfo                  ,+    constructMenuActive                     ,+    getMenuActive                           ,+    setMenuActive                           ,+++-- ** AttachWidget+    MenuAttachWidgetPropertyInfo            ,+    constructMenuAttachWidget               ,+    getMenuAttachWidget                     ,+    setMenuAttachWidget                     ,+++-- ** Monitor+    MenuMonitorPropertyInfo                 ,+    constructMenuMonitor                    ,+    getMenuMonitor                          ,+    setMenuMonitor                          ,+++-- ** ReserveToggleSize+    MenuReserveToggleSizePropertyInfo       ,+    constructMenuReserveToggleSize          ,+    getMenuReserveToggleSize                ,+    setMenuReserveToggleSize                ,+++-- ** TearoffState+    MenuTearoffStatePropertyInfo            ,+    constructMenuTearoffState               ,+    getMenuTearoffState                     ,+    setMenuTearoffState                     ,+++-- ** TearoffTitle+    MenuTearoffTitlePropertyInfo            ,+    constructMenuTearoffTitle               ,+    getMenuTearoffTitle                     ,+    setMenuTearoffTitle                     ,+++++ -- * Signals+-- ** MoveScroll+    MenuMoveScrollCallback                  ,+    MenuMoveScrollCallbackC                 ,+    MenuMoveScrollSignalInfo                ,+    afterMenuMoveScroll                     ,+    menuMoveScrollCallbackWrapper           ,+    menuMoveScrollClosure                   ,+    mkMenuMoveScrollCallback                ,+    noMenuMoveScrollCallback                ,+    onMenuMoveScroll                        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Gio as Gio++newtype Menu = Menu (ForeignPtr Menu)+foreign import ccall "gtk_menu_get_type"+    c_gtk_menu_get_type :: IO GType++type instance ParentTypes Menu = MenuParentTypes+type MenuParentTypes = '[MenuShell, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Menu where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_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++-- signal Menu::move-scroll+type MenuMoveScrollCallback =+    ScrollType ->+    IO ()++noMenuMoveScrollCallback :: Maybe MenuMoveScrollCallback+noMenuMoveScrollCallback = Nothing++type MenuMoveScrollCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuMoveScrollCallback :: MenuMoveScrollCallbackC -> IO (FunPtr MenuMoveScrollCallbackC)++menuMoveScrollClosure :: MenuMoveScrollCallback -> IO Closure+menuMoveScrollClosure cb = newCClosure =<< mkMenuMoveScrollCallback wrapped+    where wrapped = menuMoveScrollCallbackWrapper cb++menuMoveScrollCallbackWrapper ::+    MenuMoveScrollCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+menuMoveScrollCallbackWrapper _cb _ scroll_type _ = do+    let scroll_type' = (toEnum . fromIntegral) scroll_type+    _cb  scroll_type'++onMenuMoveScroll :: (GObject a, MonadIO m) => a -> MenuMoveScrollCallback -> m SignalHandlerId+onMenuMoveScroll obj cb = liftIO $ connectMenuMoveScroll obj cb SignalConnectBefore+afterMenuMoveScroll :: (GObject a, MonadIO m) => a -> MenuMoveScrollCallback -> m SignalHandlerId+afterMenuMoveScroll obj cb = connectMenuMoveScroll obj cb SignalConnectAfter++connectMenuMoveScroll :: (GObject a, MonadIO m) =>+                         a -> MenuMoveScrollCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuMoveScroll obj cb after = liftIO $ do+    cb' <- mkMenuMoveScrollCallback (menuMoveScrollCallbackWrapper cb)+    connectSignalFunPtr obj "move-scroll" cb' after++-- VVV Prop "accel-group"+   -- Type: TInterface "Gtk" "AccelGroup"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuAccelGroup :: (MonadIO m, MenuK o) => o -> m AccelGroup+getMenuAccelGroup obj = liftIO $ getObjectPropertyObject obj "accel-group" AccelGroup++setMenuAccelGroup :: (MonadIO m, MenuK o, AccelGroupK a) => o -> a -> m ()+setMenuAccelGroup obj val = liftIO $ setObjectPropertyObject obj "accel-group" val++constructMenuAccelGroup :: (AccelGroupK a) => a -> IO ([Char], GValue)+constructMenuAccelGroup val = constructObjectPropertyObject "accel-group" val++data MenuAccelGroupPropertyInfo+instance AttrInfo MenuAccelGroupPropertyInfo where+    type AttrAllowedOps MenuAccelGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuAccelGroupPropertyInfo = AccelGroupK+    type AttrBaseTypeConstraint MenuAccelGroupPropertyInfo = MenuK+    type AttrGetType MenuAccelGroupPropertyInfo = AccelGroup+    type AttrLabel MenuAccelGroupPropertyInfo = "Menu::accel-group"+    attrGet _ = getMenuAccelGroup+    attrSet _ = setMenuAccelGroup+    attrConstruct _ = constructMenuAccelGroup++-- VVV Prop "accel-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuAccelPath :: (MonadIO m, MenuK o) => o -> m T.Text+getMenuAccelPath obj = liftIO $ getObjectPropertyString obj "accel-path"++setMenuAccelPath :: (MonadIO m, MenuK o) => o -> T.Text -> m ()+setMenuAccelPath obj val = liftIO $ setObjectPropertyString obj "accel-path" val++constructMenuAccelPath :: T.Text -> IO ([Char], GValue)+constructMenuAccelPath val = constructObjectPropertyString "accel-path" val++data MenuAccelPathPropertyInfo+instance AttrInfo MenuAccelPathPropertyInfo where+    type AttrAllowedOps MenuAccelPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuAccelPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuAccelPathPropertyInfo = MenuK+    type AttrGetType MenuAccelPathPropertyInfo = T.Text+    type AttrLabel MenuAccelPathPropertyInfo = "Menu::accel-path"+    attrGet _ = getMenuAccelPath+    attrSet _ = setMenuAccelPath+    attrConstruct _ = constructMenuAccelPath++-- VVV Prop "active"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuActive :: (MonadIO m, MenuK o) => o -> m Int32+getMenuActive obj = liftIO $ getObjectPropertyCInt obj "active"++setMenuActive :: (MonadIO m, MenuK o) => o -> Int32 -> m ()+setMenuActive obj val = liftIO $ setObjectPropertyCInt obj "active" val++constructMenuActive :: Int32 -> IO ([Char], GValue)+constructMenuActive val = constructObjectPropertyCInt "active" val++data MenuActivePropertyInfo+instance AttrInfo MenuActivePropertyInfo where+    type AttrAllowedOps MenuActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuActivePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint MenuActivePropertyInfo = MenuK+    type AttrGetType MenuActivePropertyInfo = Int32+    type AttrLabel MenuActivePropertyInfo = "Menu::active"+    attrGet _ = getMenuActive+    attrSet _ = setMenuActive+    attrConstruct _ = constructMenuActive++-- VVV Prop "attach-widget"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuAttachWidget :: (MonadIO m, MenuK o) => o -> m Widget+getMenuAttachWidget obj = liftIO $ getObjectPropertyObject obj "attach-widget" Widget++setMenuAttachWidget :: (MonadIO m, MenuK o, WidgetK a) => o -> a -> m ()+setMenuAttachWidget obj val = liftIO $ setObjectPropertyObject obj "attach-widget" val++constructMenuAttachWidget :: (WidgetK a) => a -> IO ([Char], GValue)+constructMenuAttachWidget val = constructObjectPropertyObject "attach-widget" val++data MenuAttachWidgetPropertyInfo+instance AttrInfo MenuAttachWidgetPropertyInfo where+    type AttrAllowedOps MenuAttachWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuAttachWidgetPropertyInfo = WidgetK+    type AttrBaseTypeConstraint MenuAttachWidgetPropertyInfo = MenuK+    type AttrGetType MenuAttachWidgetPropertyInfo = Widget+    type AttrLabel MenuAttachWidgetPropertyInfo = "Menu::attach-widget"+    attrGet _ = getMenuAttachWidget+    attrSet _ = setMenuAttachWidget+    attrConstruct _ = constructMenuAttachWidget++-- VVV Prop "monitor"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuMonitor :: (MonadIO m, MenuK o) => o -> m Int32+getMenuMonitor obj = liftIO $ getObjectPropertyCInt obj "monitor"++setMenuMonitor :: (MonadIO m, MenuK o) => o -> Int32 -> m ()+setMenuMonitor obj val = liftIO $ setObjectPropertyCInt obj "monitor" val++constructMenuMonitor :: Int32 -> IO ([Char], GValue)+constructMenuMonitor val = constructObjectPropertyCInt "monitor" val++data MenuMonitorPropertyInfo+instance AttrInfo MenuMonitorPropertyInfo where+    type AttrAllowedOps MenuMonitorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuMonitorPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint MenuMonitorPropertyInfo = MenuK+    type AttrGetType MenuMonitorPropertyInfo = Int32+    type AttrLabel MenuMonitorPropertyInfo = "Menu::monitor"+    attrGet _ = getMenuMonitor+    attrSet _ = setMenuMonitor+    attrConstruct _ = constructMenuMonitor++-- VVV Prop "reserve-toggle-size"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuReserveToggleSize :: (MonadIO m, MenuK o) => o -> m Bool+getMenuReserveToggleSize obj = liftIO $ getObjectPropertyBool obj "reserve-toggle-size"++setMenuReserveToggleSize :: (MonadIO m, MenuK o) => o -> Bool -> m ()+setMenuReserveToggleSize obj val = liftIO $ setObjectPropertyBool obj "reserve-toggle-size" val++constructMenuReserveToggleSize :: Bool -> IO ([Char], GValue)+constructMenuReserveToggleSize val = constructObjectPropertyBool "reserve-toggle-size" val++data MenuReserveToggleSizePropertyInfo+instance AttrInfo MenuReserveToggleSizePropertyInfo where+    type AttrAllowedOps MenuReserveToggleSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuReserveToggleSizePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuReserveToggleSizePropertyInfo = MenuK+    type AttrGetType MenuReserveToggleSizePropertyInfo = Bool+    type AttrLabel MenuReserveToggleSizePropertyInfo = "Menu::reserve-toggle-size"+    attrGet _ = getMenuReserveToggleSize+    attrSet _ = setMenuReserveToggleSize+    attrConstruct _ = constructMenuReserveToggleSize++-- VVV Prop "tearoff-state"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuTearoffState :: (MonadIO m, MenuK o) => o -> m Bool+getMenuTearoffState obj = liftIO $ getObjectPropertyBool obj "tearoff-state"++setMenuTearoffState :: (MonadIO m, MenuK o) => o -> Bool -> m ()+setMenuTearoffState obj val = liftIO $ setObjectPropertyBool obj "tearoff-state" val++constructMenuTearoffState :: Bool -> IO ([Char], GValue)+constructMenuTearoffState val = constructObjectPropertyBool "tearoff-state" val++data MenuTearoffStatePropertyInfo+instance AttrInfo MenuTearoffStatePropertyInfo where+    type AttrAllowedOps MenuTearoffStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuTearoffStatePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuTearoffStatePropertyInfo = MenuK+    type AttrGetType MenuTearoffStatePropertyInfo = Bool+    type AttrLabel MenuTearoffStatePropertyInfo = "Menu::tearoff-state"+    attrGet _ = getMenuTearoffState+    attrSet _ = setMenuTearoffState+    attrConstruct _ = constructMenuTearoffState++-- VVV Prop "tearoff-title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuTearoffTitle :: (MonadIO m, MenuK o) => o -> m T.Text+getMenuTearoffTitle obj = liftIO $ getObjectPropertyString obj "tearoff-title"++setMenuTearoffTitle :: (MonadIO m, MenuK o) => o -> T.Text -> m ()+setMenuTearoffTitle obj val = liftIO $ setObjectPropertyString obj "tearoff-title" val++constructMenuTearoffTitle :: T.Text -> IO ([Char], GValue)+constructMenuTearoffTitle val = constructObjectPropertyString "tearoff-title" val++data MenuTearoffTitlePropertyInfo+instance AttrInfo MenuTearoffTitlePropertyInfo where+    type AttrAllowedOps MenuTearoffTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuTearoffTitlePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuTearoffTitlePropertyInfo = MenuK+    type AttrGetType MenuTearoffTitlePropertyInfo = T.Text+    type AttrLabel MenuTearoffTitlePropertyInfo = "Menu::tearoff-title"+    attrGet _ = getMenuTearoffTitle+    attrSet _ = setMenuTearoffTitle+    attrConstruct _ = constructMenuTearoffTitle++type instance AttributeList Menu = MenuAttributeList+type MenuAttributeList = ('[ '("accel-group", MenuAccelGroupPropertyInfo), '("accel-path", MenuAccelPathPropertyInfo), '("active", MenuActivePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("attach-widget", MenuAttachWidgetPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("monitor", MenuMonitorPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("reserve-toggle-size", MenuReserveToggleSizePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("take-focus", MenuShellTakeFocusPropertyInfo), '("tearoff-state", MenuTearoffStatePropertyInfo), '("tearoff-title", MenuTearoffTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data MenuMoveScrollSignalInfo+instance SignalInfo MenuMoveScrollSignalInfo where+    type HaskellCallbackType MenuMoveScrollSignalInfo = MenuMoveScrollCallback+    connectSignal _ = connectMenuMoveScroll++type instance SignalList Menu = MenuSignalList+type MenuSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-current", MenuShellActivateCurrentSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel", MenuShellCancelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("cycle-focus", MenuShellCycleFocusSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("deactivate", MenuShellDeactivateSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("insert", MenuShellInsertSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-current", MenuShellMoveCurrentSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-scroll", MenuMoveScrollSignalInfo), '("move-selected", MenuShellMoveSelectedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-done", MenuShellSelectionDoneSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Menu::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Menu"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_new" gtk_menu_new :: +    IO (Ptr Menu)+++menuNew ::+    (MonadIO m) =>+    m Menu+menuNew  = liftIO $ do+    result <- gtk_menu_new+    checkUnexpectedReturnNULL "gtk_menu_new" result+    result' <- (newObject Menu) result+    return result'++-- method Menu::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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Menu"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_new_from_model" gtk_menu_new_from_model :: +    Ptr Gio.MenuModel ->                    -- model : TInterface "Gio" "MenuModel"+    IO (Ptr Menu)+++menuNewFromModel ::+    (MonadIO m, Gio.MenuModelK a) =>+    a ->                                    -- model+    m Menu+menuNewFromModel model = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_menu_new_from_model model'+    checkUnexpectedReturnNULL "gtk_menu_new_from_model" result+    result' <- (newObject Menu) result+    touchManagedPtr model+    return result'++-- method Menu::attach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "right_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bottom_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "left_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "right_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top_attach", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bottom_attach", 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 "gtk_menu_attach" gtk_menu_attach :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Word32 ->                               -- left_attach : TBasicType TUInt32+    Word32 ->                               -- right_attach : TBasicType TUInt32+    Word32 ->                               -- top_attach : TBasicType TUInt32+    Word32 ->                               -- bottom_attach : TBasicType TUInt32+    IO ()+++menuAttach ::+    (MonadIO m, MenuK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Word32 ->                               -- left_attach+    Word32 ->                               -- right_attach+    Word32 ->                               -- top_attach+    Word32 ->                               -- bottom_attach+    m ()+menuAttach _obj child left_attach right_attach top_attach bottom_attach = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_menu_attach _obj' child' left_attach right_attach top_attach bottom_attach+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Menu::attach_to_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attach_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detacher", argType = TInterface "Gtk" "MenuDetachFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "attach_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detacher", argType = TInterface "Gtk" "MenuDetachFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_attach_to_widget" gtk_menu_attach_to_widget :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Widget ->                           -- attach_widget : TInterface "Gtk" "Widget"+    FunPtr MenuDetachFuncC ->               -- detacher : TInterface "Gtk" "MenuDetachFunc"+    IO ()+++menuAttachToWidget ::+    (MonadIO m, MenuK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- attach_widget+    Maybe (MenuDetachFunc) ->               -- detacher+    m ()+menuAttachToWidget _obj attach_widget detacher = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let attach_widget' = unsafeManagedPtrCastPtr attach_widget+    ptrdetacher <- callocMem :: IO (Ptr (FunPtr MenuDetachFuncC))+    maybeDetacher <- case detacher of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDetacher -> do+            jDetacher' <- mkMenuDetachFunc (menuDetachFuncWrapper (Just ptrdetacher) jDetacher)+            poke ptrdetacher jDetacher'+            return jDetacher'+    gtk_menu_attach_to_widget _obj' attach_widget' maybeDetacher+    touchManagedPtr _obj+    touchManagedPtr attach_widget+    return ()++-- method Menu::detach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_detach" gtk_menu_detach :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO ()+++menuDetach ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m ()+menuDetach _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_detach _obj'+    touchManagedPtr _obj+    return ()++-- method Menu::get_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "AccelGroup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_accel_group" gtk_menu_get_accel_group :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO (Ptr AccelGroup)+++menuGetAccelGroup ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m AccelGroup+menuGetAccelGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_accel_group _obj'+    checkUnexpectedReturnNULL "gtk_menu_get_accel_group" result+    result' <- (newObject AccelGroup) result+    touchManagedPtr _obj+    return result'++-- method Menu::get_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_accel_path" gtk_menu_get_accel_path :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO CString+++menuGetAccelPath ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m T.Text+menuGetAccelPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_accel_path _obj'+    checkUnexpectedReturnNULL "gtk_menu_get_accel_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Menu::get_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_active" gtk_menu_get_active :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO (Ptr Widget)+++menuGetActive ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m Widget+menuGetActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_active _obj'+    checkUnexpectedReturnNULL "gtk_menu_get_active" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Menu::get_attach_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_attach_widget" gtk_menu_get_attach_widget :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO (Ptr Widget)+++menuGetAttachWidget ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m Widget+menuGetAttachWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_attach_widget _obj'+    checkUnexpectedReturnNULL "gtk_menu_get_attach_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Menu::get_monitor+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_monitor" gtk_menu_get_monitor :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO Int32+++menuGetMonitor ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m Int32+menuGetMonitor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_monitor _obj'+    touchManagedPtr _obj+    return result++-- method Menu::get_reserve_toggle_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_reserve_toggle_size" gtk_menu_get_reserve_toggle_size :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO CInt+++menuGetReserveToggleSize ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m Bool+menuGetReserveToggleSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_reserve_toggle_size _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Menu::get_tearoff_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_tearoff_state" gtk_menu_get_tearoff_state :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO CInt++{-# DEPRECATED menuGetTearoffState ["(Since version 3.10)"]#-}+menuGetTearoffState ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m Bool+menuGetTearoffState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_tearoff_state _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Menu::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_title" gtk_menu_get_title :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO CString++{-# DEPRECATED menuGetTitle ["(Since version 3.10)"]#-}+menuGetTitle ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m T.Text+menuGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_get_title _obj'+    checkUnexpectedReturnNULL "gtk_menu_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Menu::popdown+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_popdown" gtk_menu_popdown :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO ()+++menuPopdown ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m ()+menuPopdown _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_popdown _obj'+    touchManagedPtr _obj+    return ()++-- method Menu::popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_shell", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "MenuPositionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activate_time", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_shell", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "MenuPositionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activate_time", 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 "gtk_menu_popup" gtk_menu_popup :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Widget ->                           -- parent_menu_shell : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- parent_menu_item : TInterface "Gtk" "Widget"+    FunPtr MenuPositionFuncC ->             -- func : TInterface "Gtk" "MenuPositionFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    Word32 ->                               -- button : TBasicType TUInt32+    Word32 ->                               -- activate_time : TBasicType TUInt32+    IO ()+++menuPopup ::+    (MonadIO m, MenuK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- parent_menu_shell+    Maybe (c) ->                            -- parent_menu_item+    Maybe (MenuPositionFunc) ->             -- func+    Word32 ->                               -- button+    Word32 ->                               -- activate_time+    m ()+menuPopup _obj parent_menu_shell parent_menu_item func button activate_time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent_menu_shell <- case parent_menu_shell of+        Nothing -> return nullPtr+        Just jParent_menu_shell -> do+            let jParent_menu_shell' = unsafeManagedPtrCastPtr jParent_menu_shell+            return jParent_menu_shell'+    maybeParent_menu_item <- case parent_menu_item of+        Nothing -> return nullPtr+        Just jParent_menu_item -> do+            let jParent_menu_item' = unsafeManagedPtrCastPtr jParent_menu_item+            return jParent_menu_item'+    ptrfunc <- callocMem :: IO (Ptr (FunPtr MenuPositionFuncC))+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkMenuPositionFunc (menuPositionFuncWrapper (Just ptrfunc) jFunc)+            poke ptrfunc jFunc'+            return jFunc'+    let data_ = nullPtr+    gtk_menu_popup _obj' maybeParent_menu_shell maybeParent_menu_item maybeFunc data_ button activate_time+    touchManagedPtr _obj+    whenJust parent_menu_shell touchManagedPtr+    whenJust parent_menu_item touchManagedPtr+    return ()++-- method Menu::popup_for_device+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_shell", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "MenuPositionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, 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},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activate_time", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "device", argType = TInterface "Gdk" "Device", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_shell", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent_menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "MenuPositionFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "button", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "activate_time", 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 "gtk_menu_popup_for_device" gtk_menu_popup_for_device :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Gdk.Device ->                       -- device : TInterface "Gdk" "Device"+    Ptr Widget ->                           -- parent_menu_shell : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- parent_menu_item : TInterface "Gtk" "Widget"+    FunPtr MenuPositionFuncC ->             -- func : TInterface "Gtk" "MenuPositionFunc"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    Word32 ->                               -- button : TBasicType TUInt32+    Word32 ->                               -- activate_time : TBasicType TUInt32+    IO ()+++menuPopupForDevice ::+    (MonadIO m, MenuK a, Gdk.DeviceK b, WidgetK c, WidgetK d) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- device+    Maybe (c) ->                            -- parent_menu_shell+    Maybe (d) ->                            -- parent_menu_item+    Maybe (MenuPositionFunc) ->             -- func+    Word32 ->                               -- button+    Word32 ->                               -- activate_time+    m ()+menuPopupForDevice _obj device parent_menu_shell parent_menu_item func button activate_time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDevice <- case device of+        Nothing -> return nullPtr+        Just jDevice -> do+            let jDevice' = unsafeManagedPtrCastPtr jDevice+            return jDevice'+    maybeParent_menu_shell <- case parent_menu_shell of+        Nothing -> return nullPtr+        Just jParent_menu_shell -> do+            let jParent_menu_shell' = unsafeManagedPtrCastPtr jParent_menu_shell+            return jParent_menu_shell'+    maybeParent_menu_item <- case parent_menu_item of+        Nothing -> return nullPtr+        Just jParent_menu_item -> do+            let jParent_menu_item' = unsafeManagedPtrCastPtr jParent_menu_item+            return jParent_menu_item'+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkMenuPositionFunc (menuPositionFuncWrapper Nothing jFunc)+            return jFunc'+    let data_ = castFunPtrToPtr maybeFunc+    let destroy = safeFreeFunPtrPtr+    gtk_menu_popup_for_device _obj' maybeDevice maybeParent_menu_shell maybeParent_menu_item maybeFunc data_ destroy button activate_time+    touchManagedPtr _obj+    whenJust device touchManagedPtr+    whenJust parent_menu_shell touchManagedPtr+    whenJust parent_menu_item touchManagedPtr+    return ()++-- method Menu::reorder_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_menu_reorder_child" gtk_menu_reorder_child :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++menuReorderChild ::+    (MonadIO m, MenuK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+menuReorderChild _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_menu_reorder_child _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Menu::reposition+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_reposition" gtk_menu_reposition :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    IO ()+++menuReposition ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    m ()+menuReposition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_reposition _obj'+    touchManagedPtr _obj+    return ()++-- method Menu::set_accel_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_group", argType = TInterface "Gtk" "AccelGroup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_set_accel_group" gtk_menu_set_accel_group :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr AccelGroup ->                       -- accel_group : TInterface "Gtk" "AccelGroup"+    IO ()+++menuSetAccelGroup ::+    (MonadIO m, MenuK a, AccelGroupK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- accel_group+    m ()+menuSetAccelGroup _obj accel_group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAccel_group <- case accel_group of+        Nothing -> return nullPtr+        Just jAccel_group -> do+            let jAccel_group' = unsafeManagedPtrCastPtr jAccel_group+            return jAccel_group'+    gtk_menu_set_accel_group _obj' maybeAccel_group+    touchManagedPtr _obj+    whenJust accel_group touchManagedPtr+    return ()++-- method Menu::set_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_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 "gtk_menu_set_accel_path" gtk_menu_set_accel_path :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    CString ->                              -- accel_path : TBasicType TUTF8+    IO ()+++menuSetAccelPath ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- accel_path+    m ()+menuSetAccelPath _obj accel_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAccel_path <- case accel_path of+        Nothing -> return nullPtr+        Just jAccel_path -> do+            jAccel_path' <- textToCString jAccel_path+            return jAccel_path'+    gtk_menu_set_accel_path _obj' maybeAccel_path+    touchManagedPtr _obj+    freeMem maybeAccel_path+    return ()++-- method Menu::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", 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 "gtk_menu_set_active" gtk_menu_set_active :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Word32 ->                               -- index : TBasicType TUInt32+    IO ()+++menuSetActive ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Word32 ->                               -- index+    m ()+menuSetActive _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_set_active _obj' index+    touchManagedPtr _obj+    return ()++-- method Menu::set_monitor+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "monitor_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "monitor_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 "gtk_menu_set_monitor" gtk_menu_set_monitor :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Int32 ->                                -- monitor_num : TBasicType TInt32+    IO ()+++menuSetMonitor ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- monitor_num+    m ()+menuSetMonitor _obj monitor_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_set_monitor _obj' monitor_num+    touchManagedPtr _obj+    return ()++-- method Menu::set_reserve_toggle_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reserve_toggle_size", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reserve_toggle_size", 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 "gtk_menu_set_reserve_toggle_size" gtk_menu_set_reserve_toggle_size :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    CInt ->                                 -- reserve_toggle_size : TBasicType TBoolean+    IO ()+++menuSetReserveToggleSize ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- reserve_toggle_size+    m ()+menuSetReserveToggleSize _obj reserve_toggle_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let reserve_toggle_size' = (fromIntegral . fromEnum) reserve_toggle_size+    gtk_menu_set_reserve_toggle_size _obj' reserve_toggle_size'+    touchManagedPtr _obj+    return ()++-- method Menu::set_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_set_screen" gtk_menu_set_screen :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO ()+++menuSetScreen ::+    (MonadIO m, MenuK a, Gdk.ScreenK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- screen+    m ()+menuSetScreen _obj screen = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeScreen <- case screen of+        Nothing -> return nullPtr+        Just jScreen -> do+            let jScreen' = unsafeManagedPtrCastPtr jScreen+            return jScreen'+    gtk_menu_set_screen _obj' maybeScreen+    touchManagedPtr _obj+    whenJust screen touchManagedPtr+    return ()++-- method Menu::set_tearoff_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "torn_off", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "torn_off", 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 "gtk_menu_set_tearoff_state" gtk_menu_set_tearoff_state :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    CInt ->                                 -- torn_off : TBasicType TBoolean+    IO ()++{-# DEPRECATED menuSetTearoffState ["(Since version 3.10)"]#-}+menuSetTearoffState ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- torn_off+    m ()+menuSetTearoffState _obj torn_off = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let torn_off' = (fromIntegral . fromEnum) torn_off+    gtk_menu_set_tearoff_state _obj' torn_off'+    touchManagedPtr _obj+    return ()++-- method Menu::set_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Menu", 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 "Gtk" "Menu", 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 "gtk_menu_set_title" gtk_menu_set_title :: +    Ptr Menu ->                             -- _obj : TInterface "Gtk" "Menu"+    CString ->                              -- title : TBasicType TUTF8+    IO ()++{-# DEPRECATED menuSetTitle ["(Since version 3.10)"]#-}+menuSetTitle ::+    (MonadIO m, MenuK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- title+    m ()+menuSetTitle _obj title = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    title' <- textToCString title+    gtk_menu_set_title _obj' title'+    touchManagedPtr _obj+    freeMem title'+    return ()++-- method Menu::get_for_attach_widget+-- method type : MemberFunction+-- Args : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Gtk" "Widget")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_get_for_attach_widget" gtk_menu_get_for_attach_widget :: +    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO (Ptr (GList (Ptr Widget)))+++menuGetForAttachWidget ::+    (MonadIO m, WidgetK a) =>+    a ->                                    -- widget+    m [Widget]+menuGetForAttachWidget widget = liftIO $ do+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_menu_get_for_attach_widget widget'+    checkUnexpectedReturnNULL "gtk_menu_get_for_attach_widget" result+    result' <- unpackGList result+    result'' <- mapM (newObject Widget) result'+    touchManagedPtr widget+    return result''++
+ GI/Gtk/Objects/Menu.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gtk.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+data MenuAccelGroupPropertyInfo+data MenuAccelPathPropertyInfo+data MenuActivePropertyInfo+data MenuAttachWidgetPropertyInfo+data MenuMonitorPropertyInfo+data MenuReserveToggleSizePropertyInfo+data MenuTearoffStatePropertyInfo+data MenuTearoffTitlePropertyInfo+data MenuMoveScrollSignalInfo
+ GI/Gtk/Objects/MenuAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.MenuAccessible+    ( ++-- * Exported types+    MenuAccessible(..)                      ,+    MenuAccessibleK                         ,+    toMenuAccessible                        ,+    noMenuAccessible                        ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuAccessible = MenuAccessible (ForeignPtr MenuAccessible)+foreign import ccall "gtk_menu_accessible_get_type"+    c_gtk_menu_accessible_get_type :: IO GType++type instance ParentTypes MenuAccessible = MenuAccessibleParentTypes+type MenuAccessibleParentTypes = '[MenuShellAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject MenuAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_menu_accessible_get_type+    ++class GObject o => MenuAccessibleK o+instance (GObject o, IsDescendantOf MenuAccessible o) => MenuAccessibleK o++toMenuAccessible :: MenuAccessibleK o => o -> IO MenuAccessible+toMenuAccessible = unsafeCastTo MenuAccessible++noMenuAccessible :: Maybe MenuAccessible+noMenuAccessible = Nothing++type instance AttributeList MenuAccessible = MenuAccessibleAttributeList+type MenuAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuAccessible = MenuAccessibleSignalList+type MenuAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/MenuAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.MenuAccessible where++import Prelude ()+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 MenuAccessible = MenuAccessible (ForeignPtr MenuAccessible)+instance GObject MenuAccessible where+class GObject o => MenuAccessibleK o+instance (GObject o, IsDescendantOf MenuAccessible o) => MenuAccessibleK o
+ GI/Gtk/Objects/MenuBar.hs view
@@ -0,0 +1,304 @@++{- |+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.Gtk.Objects.MenuBar+    ( ++-- * Exported types+    MenuBar(..)                             ,+    MenuBarK                                ,+    toMenuBar                               ,+    noMenuBar                               ,+++ -- * Methods+-- ** menuBarGetChildPackDirection+    menuBarGetChildPackDirection            ,+++-- ** menuBarGetPackDirection+    menuBarGetPackDirection                 ,+++-- ** menuBarNew+    menuBarNew                              ,+++-- ** menuBarNewFromModel+    menuBarNewFromModel                     ,+++-- ** menuBarSetChildPackDirection+    menuBarSetChildPackDirection            ,+++-- ** menuBarSetPackDirection+    menuBarSetPackDirection                 ,+++++ -- * Properties+-- ** ChildPackDirection+    MenuBarChildPackDirectionPropertyInfo   ,+    constructMenuBarChildPackDirection      ,+    getMenuBarChildPackDirection            ,+    setMenuBarChildPackDirection            ,+++-- ** PackDirection+    MenuBarPackDirectionPropertyInfo        ,+    constructMenuBarPackDirection           ,+    getMenuBarPackDirection                 ,+    setMenuBarPackDirection                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype MenuBar = MenuBar (ForeignPtr MenuBar)+foreign import ccall "gtk_menu_bar_get_type"+    c_gtk_menu_bar_get_type :: IO GType++type instance ParentTypes MenuBar = MenuBarParentTypes+type MenuBarParentTypes = '[MenuShell, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject MenuBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_menu_bar_get_type+    ++class GObject o => MenuBarK o+instance (GObject o, IsDescendantOf MenuBar o) => MenuBarK o++toMenuBar :: MenuBarK o => o -> IO MenuBar+toMenuBar = unsafeCastTo MenuBar++noMenuBar :: Maybe MenuBar+noMenuBar = Nothing++-- VVV Prop "child-pack-direction"+   -- Type: TInterface "Gtk" "PackDirection"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuBarChildPackDirection :: (MonadIO m, MenuBarK o) => o -> m PackDirection+getMenuBarChildPackDirection obj = liftIO $ getObjectPropertyEnum obj "child-pack-direction"++setMenuBarChildPackDirection :: (MonadIO m, MenuBarK o) => o -> PackDirection -> m ()+setMenuBarChildPackDirection obj val = liftIO $ setObjectPropertyEnum obj "child-pack-direction" val++constructMenuBarChildPackDirection :: PackDirection -> IO ([Char], GValue)+constructMenuBarChildPackDirection val = constructObjectPropertyEnum "child-pack-direction" val++data MenuBarChildPackDirectionPropertyInfo+instance AttrInfo MenuBarChildPackDirectionPropertyInfo where+    type AttrAllowedOps MenuBarChildPackDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuBarChildPackDirectionPropertyInfo = (~) PackDirection+    type AttrBaseTypeConstraint MenuBarChildPackDirectionPropertyInfo = MenuBarK+    type AttrGetType MenuBarChildPackDirectionPropertyInfo = PackDirection+    type AttrLabel MenuBarChildPackDirectionPropertyInfo = "MenuBar::child-pack-direction"+    attrGet _ = getMenuBarChildPackDirection+    attrSet _ = setMenuBarChildPackDirection+    attrConstruct _ = constructMenuBarChildPackDirection++-- VVV Prop "pack-direction"+   -- Type: TInterface "Gtk" "PackDirection"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuBarPackDirection :: (MonadIO m, MenuBarK o) => o -> m PackDirection+getMenuBarPackDirection obj = liftIO $ getObjectPropertyEnum obj "pack-direction"++setMenuBarPackDirection :: (MonadIO m, MenuBarK o) => o -> PackDirection -> m ()+setMenuBarPackDirection obj val = liftIO $ setObjectPropertyEnum obj "pack-direction" val++constructMenuBarPackDirection :: PackDirection -> IO ([Char], GValue)+constructMenuBarPackDirection val = constructObjectPropertyEnum "pack-direction" val++data MenuBarPackDirectionPropertyInfo+instance AttrInfo MenuBarPackDirectionPropertyInfo where+    type AttrAllowedOps MenuBarPackDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuBarPackDirectionPropertyInfo = (~) PackDirection+    type AttrBaseTypeConstraint MenuBarPackDirectionPropertyInfo = MenuBarK+    type AttrGetType MenuBarPackDirectionPropertyInfo = PackDirection+    type AttrLabel MenuBarPackDirectionPropertyInfo = "MenuBar::pack-direction"+    attrGet _ = getMenuBarPackDirection+    attrSet _ = setMenuBarPackDirection+    attrConstruct _ = constructMenuBarPackDirection++type instance AttributeList MenuBar = MenuBarAttributeList+type MenuBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("child-pack-direction", MenuBarChildPackDirectionPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("pack-direction", MenuBarPackDirectionPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("take-focus", MenuShellTakeFocusPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuBar = MenuBarSignalList+type MenuBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-current", MenuShellActivateCurrentSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel", MenuShellCancelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("cycle-focus", MenuShellCycleFocusSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("deactivate", MenuShellDeactivateSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("insert", MenuShellInsertSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-current", MenuShellMoveCurrentSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-selected", MenuShellMoveSelectedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-done", MenuShellSelectionDoneSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "MenuBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_new" gtk_menu_bar_new :: +    IO (Ptr MenuBar)+++menuBarNew ::+    (MonadIO m) =>+    m MenuBar+menuBarNew  = liftIO $ do+    result <- gtk_menu_bar_new+    checkUnexpectedReturnNULL "gtk_menu_bar_new" result+    result' <- (newObject MenuBar) result+    return result'++-- method MenuBar::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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MenuBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_new_from_model" gtk_menu_bar_new_from_model :: +    Ptr Gio.MenuModel ->                    -- model : TInterface "Gio" "MenuModel"+    IO (Ptr MenuBar)+++menuBarNewFromModel ::+    (MonadIO m, Gio.MenuModelK a) =>+    a ->                                    -- model+    m MenuBar+menuBarNewFromModel model = liftIO $ do+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_menu_bar_new_from_model model'+    checkUnexpectedReturnNULL "gtk_menu_bar_new_from_model" result+    result' <- (newObject MenuBar) result+    touchManagedPtr model+    return result'++-- method MenuBar::get_child_pack_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PackDirection"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_get_child_pack_direction" gtk_menu_bar_get_child_pack_direction :: +    Ptr MenuBar ->                          -- _obj : TInterface "Gtk" "MenuBar"+    IO CUInt+++menuBarGetChildPackDirection ::+    (MonadIO m, MenuBarK a) =>+    a ->                                    -- _obj+    m PackDirection+menuBarGetChildPackDirection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_bar_get_child_pack_direction _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method MenuBar::get_pack_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PackDirection"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_get_pack_direction" gtk_menu_bar_get_pack_direction :: +    Ptr MenuBar ->                          -- _obj : TInterface "Gtk" "MenuBar"+    IO CUInt+++menuBarGetPackDirection ::+    (MonadIO m, MenuBarK a) =>+    a ->                                    -- _obj+    m PackDirection+menuBarGetPackDirection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_bar_get_pack_direction _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method MenuBar::set_child_pack_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_pack_dir", argType = TInterface "Gtk" "PackDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child_pack_dir", argType = TInterface "Gtk" "PackDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_set_child_pack_direction" gtk_menu_bar_set_child_pack_direction :: +    Ptr MenuBar ->                          -- _obj : TInterface "Gtk" "MenuBar"+    CUInt ->                                -- child_pack_dir : TInterface "Gtk" "PackDirection"+    IO ()+++menuBarSetChildPackDirection ::+    (MonadIO m, MenuBarK a) =>+    a ->                                    -- _obj+    PackDirection ->                        -- child_pack_dir+    m ()+menuBarSetChildPackDirection _obj child_pack_dir = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child_pack_dir' = (fromIntegral . fromEnum) child_pack_dir+    gtk_menu_bar_set_child_pack_direction _obj' child_pack_dir'+    touchManagedPtr _obj+    return ()++-- method MenuBar::set_pack_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_dir", argType = TInterface "Gtk" "PackDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_dir", argType = TInterface "Gtk" "PackDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_bar_set_pack_direction" gtk_menu_bar_set_pack_direction :: +    Ptr MenuBar ->                          -- _obj : TInterface "Gtk" "MenuBar"+    CUInt ->                                -- pack_dir : TInterface "Gtk" "PackDirection"+    IO ()+++menuBarSetPackDirection ::+    (MonadIO m, MenuBarK a) =>+    a ->                                    -- _obj+    PackDirection ->                        -- pack_dir+    m ()+menuBarSetPackDirection _obj pack_dir = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pack_dir' = (fromIntegral . fromEnum) pack_dir+    gtk_menu_bar_set_pack_direction _obj' pack_dir'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/MenuBar.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.MenuBar where++import Prelude ()+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 MenuBar = MenuBar (ForeignPtr MenuBar)+instance GObject MenuBar where+class GObject o => MenuBarK o+instance (GObject o, IsDescendantOf MenuBar o) => MenuBarK o+data MenuBarChildPackDirectionPropertyInfo+data MenuBarPackDirectionPropertyInfo
+ GI/Gtk/Objects/MenuButton.hs view
@@ -0,0 +1,662 @@++{- |+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.Gtk.Objects.MenuButton+    ( ++-- * Exported types+    MenuButton(..)                          ,+    MenuButtonK                             ,+    toMenuButton                            ,+    noMenuButton                            ,+++ -- * Methods+-- ** menuButtonGetAlignWidget+    menuButtonGetAlignWidget                ,+++-- ** menuButtonGetDirection+    menuButtonGetDirection                  ,+++-- ** menuButtonGetMenuModel+    menuButtonGetMenuModel                  ,+++-- ** menuButtonGetPopover+    menuButtonGetPopover                    ,+++-- ** menuButtonGetPopup+    menuButtonGetPopup                      ,+++-- ** menuButtonGetUsePopover+    menuButtonGetUsePopover                 ,+++-- ** menuButtonNew+    menuButtonNew                           ,+++-- ** menuButtonSetAlignWidget+    menuButtonSetAlignWidget                ,+++-- ** menuButtonSetDirection+    menuButtonSetDirection                  ,+++-- ** menuButtonSetMenuModel+    menuButtonSetMenuModel                  ,+++-- ** menuButtonSetPopover+    menuButtonSetPopover                    ,+++-- ** menuButtonSetPopup+    menuButtonSetPopup                      ,+++-- ** menuButtonSetUsePopover+    menuButtonSetUsePopover                 ,+++++ -- * Properties+-- ** AlignWidget+    MenuButtonAlignWidgetPropertyInfo       ,+    constructMenuButtonAlignWidget          ,+    getMenuButtonAlignWidget                ,+    setMenuButtonAlignWidget                ,+++-- ** Direction+    MenuButtonDirectionPropertyInfo         ,+    constructMenuButtonDirection            ,+    getMenuButtonDirection                  ,+    setMenuButtonDirection                  ,+++-- ** MenuModel+    MenuButtonMenuModelPropertyInfo         ,+    constructMenuButtonMenuModel            ,+    getMenuButtonMenuModel                  ,+    setMenuButtonMenuModel                  ,+++-- ** Popover+    MenuButtonPopoverPropertyInfo           ,+    constructMenuButtonPopover              ,+    getMenuButtonPopover                    ,+    setMenuButtonPopover                    ,+++-- ** Popup+    MenuButtonPopupPropertyInfo             ,+    constructMenuButtonPopup                ,+    getMenuButtonPopup                      ,+    setMenuButtonPopup                      ,+++-- ** UsePopover+    MenuButtonUsePopoverPropertyInfo        ,+    constructMenuButtonUsePopover           ,+    getMenuButtonUsePopover                 ,+    setMenuButtonUsePopover                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype MenuButton = MenuButton (ForeignPtr MenuButton)+foreign import ccall "gtk_menu_button_get_type"+    c_gtk_menu_button_get_type :: IO GType++type instance ParentTypes MenuButton = MenuButtonParentTypes+type MenuButtonParentTypes = '[ToggleButton, Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject MenuButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_menu_button_get_type+    ++class GObject o => MenuButtonK o+instance (GObject o, IsDescendantOf MenuButton o) => MenuButtonK o++toMenuButton :: MenuButtonK o => o -> IO MenuButton+toMenuButton = unsafeCastTo MenuButton++noMenuButton :: Maybe MenuButton+noMenuButton = Nothing++-- VVV Prop "align-widget"+   -- Type: TInterface "Gtk" "Container"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonAlignWidget :: (MonadIO m, MenuButtonK o) => o -> m Container+getMenuButtonAlignWidget obj = liftIO $ getObjectPropertyObject obj "align-widget" Container++setMenuButtonAlignWidget :: (MonadIO m, MenuButtonK o, ContainerK a) => o -> a -> m ()+setMenuButtonAlignWidget obj val = liftIO $ setObjectPropertyObject obj "align-widget" val++constructMenuButtonAlignWidget :: (ContainerK a) => a -> IO ([Char], GValue)+constructMenuButtonAlignWidget val = constructObjectPropertyObject "align-widget" val++data MenuButtonAlignWidgetPropertyInfo+instance AttrInfo MenuButtonAlignWidgetPropertyInfo where+    type AttrAllowedOps MenuButtonAlignWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonAlignWidgetPropertyInfo = ContainerK+    type AttrBaseTypeConstraint MenuButtonAlignWidgetPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonAlignWidgetPropertyInfo = Container+    type AttrLabel MenuButtonAlignWidgetPropertyInfo = "MenuButton::align-widget"+    attrGet _ = getMenuButtonAlignWidget+    attrSet _ = setMenuButtonAlignWidget+    attrConstruct _ = constructMenuButtonAlignWidget++-- VVV Prop "direction"+   -- Type: TInterface "Gtk" "ArrowType"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonDirection :: (MonadIO m, MenuButtonK o) => o -> m ArrowType+getMenuButtonDirection obj = liftIO $ getObjectPropertyEnum obj "direction"++setMenuButtonDirection :: (MonadIO m, MenuButtonK o) => o -> ArrowType -> m ()+setMenuButtonDirection obj val = liftIO $ setObjectPropertyEnum obj "direction" val++constructMenuButtonDirection :: ArrowType -> IO ([Char], GValue)+constructMenuButtonDirection val = constructObjectPropertyEnum "direction" val++data MenuButtonDirectionPropertyInfo+instance AttrInfo MenuButtonDirectionPropertyInfo where+    type AttrAllowedOps MenuButtonDirectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonDirectionPropertyInfo = (~) ArrowType+    type AttrBaseTypeConstraint MenuButtonDirectionPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonDirectionPropertyInfo = ArrowType+    type AttrLabel MenuButtonDirectionPropertyInfo = "MenuButton::direction"+    attrGet _ = getMenuButtonDirection+    attrSet _ = setMenuButtonDirection+    attrConstruct _ = constructMenuButtonDirection++-- VVV Prop "menu-model"+   -- Type: TInterface "Gio" "MenuModel"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonMenuModel :: (MonadIO m, MenuButtonK o) => o -> m Gio.MenuModel+getMenuButtonMenuModel obj = liftIO $ getObjectPropertyObject obj "menu-model" Gio.MenuModel++setMenuButtonMenuModel :: (MonadIO m, MenuButtonK o, Gio.MenuModelK a) => o -> a -> m ()+setMenuButtonMenuModel obj val = liftIO $ setObjectPropertyObject obj "menu-model" val++constructMenuButtonMenuModel :: (Gio.MenuModelK a) => a -> IO ([Char], GValue)+constructMenuButtonMenuModel val = constructObjectPropertyObject "menu-model" val++data MenuButtonMenuModelPropertyInfo+instance AttrInfo MenuButtonMenuModelPropertyInfo where+    type AttrAllowedOps MenuButtonMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonMenuModelPropertyInfo = Gio.MenuModelK+    type AttrBaseTypeConstraint MenuButtonMenuModelPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonMenuModelPropertyInfo = Gio.MenuModel+    type AttrLabel MenuButtonMenuModelPropertyInfo = "MenuButton::menu-model"+    attrGet _ = getMenuButtonMenuModel+    attrSet _ = setMenuButtonMenuModel+    attrConstruct _ = constructMenuButtonMenuModel++-- VVV Prop "popover"+   -- Type: TInterface "Gtk" "Popover"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonPopover :: (MonadIO m, MenuButtonK o) => o -> m Popover+getMenuButtonPopover obj = liftIO $ getObjectPropertyObject obj "popover" Popover++setMenuButtonPopover :: (MonadIO m, MenuButtonK o, PopoverK a) => o -> a -> m ()+setMenuButtonPopover obj val = liftIO $ setObjectPropertyObject obj "popover" val++constructMenuButtonPopover :: (PopoverK a) => a -> IO ([Char], GValue)+constructMenuButtonPopover val = constructObjectPropertyObject "popover" val++data MenuButtonPopoverPropertyInfo+instance AttrInfo MenuButtonPopoverPropertyInfo where+    type AttrAllowedOps MenuButtonPopoverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonPopoverPropertyInfo = PopoverK+    type AttrBaseTypeConstraint MenuButtonPopoverPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonPopoverPropertyInfo = Popover+    type AttrLabel MenuButtonPopoverPropertyInfo = "MenuButton::popover"+    attrGet _ = getMenuButtonPopover+    attrSet _ = setMenuButtonPopover+    attrConstruct _ = constructMenuButtonPopover++-- VVV Prop "popup"+   -- Type: TInterface "Gtk" "Menu"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonPopup :: (MonadIO m, MenuButtonK o) => o -> m Menu+getMenuButtonPopup obj = liftIO $ getObjectPropertyObject obj "popup" Menu++setMenuButtonPopup :: (MonadIO m, MenuButtonK o, MenuK a) => o -> a -> m ()+setMenuButtonPopup obj val = liftIO $ setObjectPropertyObject obj "popup" val++constructMenuButtonPopup :: (MenuK a) => a -> IO ([Char], GValue)+constructMenuButtonPopup val = constructObjectPropertyObject "popup" val++data MenuButtonPopupPropertyInfo+instance AttrInfo MenuButtonPopupPropertyInfo where+    type AttrAllowedOps MenuButtonPopupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonPopupPropertyInfo = MenuK+    type AttrBaseTypeConstraint MenuButtonPopupPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonPopupPropertyInfo = Menu+    type AttrLabel MenuButtonPopupPropertyInfo = "MenuButton::popup"+    attrGet _ = getMenuButtonPopup+    attrSet _ = setMenuButtonPopup+    attrConstruct _ = constructMenuButtonPopup++-- VVV Prop "use-popover"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuButtonUsePopover :: (MonadIO m, MenuButtonK o) => o -> m Bool+getMenuButtonUsePopover obj = liftIO $ getObjectPropertyBool obj "use-popover"++setMenuButtonUsePopover :: (MonadIO m, MenuButtonK o) => o -> Bool -> m ()+setMenuButtonUsePopover obj val = liftIO $ setObjectPropertyBool obj "use-popover" val++constructMenuButtonUsePopover :: Bool -> IO ([Char], GValue)+constructMenuButtonUsePopover val = constructObjectPropertyBool "use-popover" val++data MenuButtonUsePopoverPropertyInfo+instance AttrInfo MenuButtonUsePopoverPropertyInfo where+    type AttrAllowedOps MenuButtonUsePopoverPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuButtonUsePopoverPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuButtonUsePopoverPropertyInfo = MenuButtonK+    type AttrGetType MenuButtonUsePopoverPropertyInfo = Bool+    type AttrLabel MenuButtonUsePopoverPropertyInfo = "MenuButton::use-popover"+    attrGet _ = getMenuButtonUsePopover+    attrSet _ = setMenuButtonUsePopover+    attrConstruct _ = constructMenuButtonUsePopover++type instance AttributeList MenuButton = MenuButtonAttributeList+type MenuButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", ToggleButtonActivePropertyInfo), '("align-widget", MenuButtonAlignWidgetPropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("direction", MenuButtonDirectionPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-indicator", ToggleButtonDrawIndicatorPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("inconsistent", ToggleButtonInconsistentPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("menu-model", MenuButtonMenuModelPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("popover", MenuButtonPopoverPropertyInfo), '("popup", MenuButtonPopupPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-popover", MenuButtonUsePopoverPropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuButton = MenuButtonSignalList+type MenuButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggled", ToggleButtonToggledSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuButton::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "MenuButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_new" gtk_menu_button_new :: +    IO (Ptr MenuButton)+++menuButtonNew ::+    (MonadIO m) =>+    m MenuButton+menuButtonNew  = liftIO $ do+    result <- gtk_menu_button_new+    checkUnexpectedReturnNULL "gtk_menu_button_new" result+    result' <- (newObject MenuButton) result+    return result'++-- method MenuButton::get_align_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_align_widget" gtk_menu_button_get_align_widget :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO (Ptr Widget)+++menuButtonGetAlignWidget ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m Widget+menuButtonGetAlignWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_align_widget _obj'+    checkUnexpectedReturnNULL "gtk_menu_button_get_align_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::get_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "ArrowType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_direction" gtk_menu_button_get_direction :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO CUInt+++menuButtonGetDirection ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m ArrowType+menuButtonGetDirection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_direction _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::get_menu_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "MenuModel"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_menu_model" gtk_menu_button_get_menu_model :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO (Ptr Gio.MenuModel)+++menuButtonGetMenuModel ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m Gio.MenuModel+menuButtonGetMenuModel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_menu_model _obj'+    checkUnexpectedReturnNULL "gtk_menu_button_get_menu_model" result+    result' <- (newObject Gio.MenuModel) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::get_popover+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Popover"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_popover" gtk_menu_button_get_popover :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO (Ptr Popover)+++menuButtonGetPopover ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m Popover+menuButtonGetPopover _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_popover _obj'+    checkUnexpectedReturnNULL "gtk_menu_button_get_popover" result+    result' <- (newObject Popover) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::get_popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Menu"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_popup" gtk_menu_button_get_popup :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO (Ptr Menu)+++menuButtonGetPopup ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m Menu+menuButtonGetPopup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_popup _obj'+    checkUnexpectedReturnNULL "gtk_menu_button_get_popup" result+    result' <- (newObject Menu) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::get_use_popover+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_get_use_popover" gtk_menu_button_get_use_popover :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    IO CInt+++menuButtonGetUsePopover ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    m Bool+menuButtonGetUsePopover _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_button_get_use_popover _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuButton::set_align_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "align_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_set_align_widget" gtk_menu_button_set_align_widget :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    Ptr Widget ->                           -- align_widget : TInterface "Gtk" "Widget"+    IO ()+++menuButtonSetAlignWidget ::+    (MonadIO m, MenuButtonK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- align_widget+    m ()+menuButtonSetAlignWidget _obj align_widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAlign_widget <- case align_widget of+        Nothing -> return nullPtr+        Just jAlign_widget -> do+            let jAlign_widget' = unsafeManagedPtrCastPtr jAlign_widget+            return jAlign_widget'+    gtk_menu_button_set_align_widget _obj' maybeAlign_widget+    touchManagedPtr _obj+    whenJust align_widget touchManagedPtr+    return ()++-- method MenuButton::set_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "direction", argType = TInterface "Gtk" "ArrowType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_set_direction" gtk_menu_button_set_direction :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    CUInt ->                                -- direction : TInterface "Gtk" "ArrowType"+    IO ()+++menuButtonSetDirection ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    ArrowType ->                            -- direction+    m ()+menuButtonSetDirection _obj direction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let direction' = (fromIntegral . fromEnum) direction+    gtk_menu_button_set_direction _obj' direction'+    touchManagedPtr _obj+    return ()++-- method MenuButton::set_menu_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_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 "gtk_menu_button_set_menu_model" gtk_menu_button_set_menu_model :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    Ptr Gio.MenuModel ->                    -- menu_model : TInterface "Gio" "MenuModel"+    IO ()+++menuButtonSetMenuModel ::+    (MonadIO m, MenuButtonK a, Gio.MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- menu_model+    m ()+menuButtonSetMenuModel _obj menu_model = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeMenu_model <- case menu_model of+        Nothing -> return nullPtr+        Just jMenu_model -> do+            let jMenu_model' = unsafeManagedPtrCastPtr jMenu_model+            return jMenu_model'+    gtk_menu_button_set_menu_model _obj' maybeMenu_model+    touchManagedPtr _obj+    whenJust menu_model touchManagedPtr+    return ()++-- method MenuButton::set_popover+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popover", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popover", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_set_popover" gtk_menu_button_set_popover :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    Ptr Widget ->                           -- popover : TInterface "Gtk" "Widget"+    IO ()+++menuButtonSetPopover ::+    (MonadIO m, MenuButtonK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- popover+    m ()+menuButtonSetPopover _obj popover = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePopover <- case popover of+        Nothing -> return nullPtr+        Just jPopover -> do+            let jPopover' = unsafeManagedPtrCastPtr jPopover+            return jPopover'+    gtk_menu_button_set_popover _obj' maybePopover+    touchManagedPtr _obj+    whenJust popover touchManagedPtr+    return ()++-- method MenuButton::set_popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_button_set_popup" gtk_menu_button_set_popup :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    Ptr Widget ->                           -- menu : TInterface "Gtk" "Widget"+    IO ()+++menuButtonSetPopup ::+    (MonadIO m, MenuButtonK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- menu+    m ()+menuButtonSetPopup _obj menu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeMenu <- case menu of+        Nothing -> return nullPtr+        Just jMenu -> do+            let jMenu' = unsafeManagedPtrCastPtr jMenu+            return jMenu'+    gtk_menu_button_set_popup _obj' maybeMenu+    touchManagedPtr _obj+    whenJust menu touchManagedPtr+    return ()++-- method MenuButton::set_use_popover+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_popover", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_popover", 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 "gtk_menu_button_set_use_popover" gtk_menu_button_set_use_popover :: +    Ptr MenuButton ->                       -- _obj : TInterface "Gtk" "MenuButton"+    CInt ->                                 -- use_popover : TBasicType TBoolean+    IO ()+++menuButtonSetUsePopover ::+    (MonadIO m, MenuButtonK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_popover+    m ()+menuButtonSetUsePopover _obj use_popover = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_popover' = (fromIntegral . fromEnum) use_popover+    gtk_menu_button_set_use_popover _obj' use_popover'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/MenuButton.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.MenuButton where++import Prelude ()+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 MenuButton = MenuButton (ForeignPtr MenuButton)+instance GObject MenuButton where+class GObject o => MenuButtonK o+instance (GObject o, IsDescendantOf MenuButton o) => MenuButtonK o+data MenuButtonAlignWidgetPropertyInfo+data MenuButtonDirectionPropertyInfo+data MenuButtonMenuModelPropertyInfo+data MenuButtonPopoverPropertyInfo+data MenuButtonPopupPropertyInfo+data MenuButtonUsePopoverPropertyInfo
+ GI/Gtk/Objects/MenuButtonAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.MenuButtonAccessible+    ( ++-- * Exported types+    MenuButtonAccessible(..)                ,+    MenuButtonAccessibleK                   ,+    toMenuButtonAccessible                  ,+    noMenuButtonAccessible                  ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuButtonAccessible = MenuButtonAccessible (ForeignPtr MenuButtonAccessible)+foreign import ccall "gtk_menu_button_accessible_get_type"+    c_gtk_menu_button_accessible_get_type :: IO GType++type instance ParentTypes MenuButtonAccessible = MenuButtonAccessibleParentTypes+type MenuButtonAccessibleParentTypes = '[ToggleButtonAccessible, ButtonAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Image]++instance GObject MenuButtonAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_menu_button_accessible_get_type+    ++class GObject o => MenuButtonAccessibleK o+instance (GObject o, IsDescendantOf MenuButtonAccessible o) => MenuButtonAccessibleK o++toMenuButtonAccessible :: MenuButtonAccessibleK o => o -> IO MenuButtonAccessible+toMenuButtonAccessible = unsafeCastTo MenuButtonAccessible++noMenuButtonAccessible :: Maybe MenuButtonAccessible+noMenuButtonAccessible = Nothing++type instance AttributeList MenuButtonAccessible = MenuButtonAccessibleAttributeList+type MenuButtonAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuButtonAccessible = MenuButtonAccessibleSignalList+type MenuButtonAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/MenuButtonAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.MenuButtonAccessible where++import Prelude ()+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 MenuButtonAccessible = MenuButtonAccessible (ForeignPtr MenuButtonAccessible)+instance GObject MenuButtonAccessible where+class GObject o => MenuButtonAccessibleK o+instance (GObject o, IsDescendantOf MenuButtonAccessible o) => MenuButtonAccessibleK o
+ GI/Gtk/Objects/MenuItem.hs view
@@ -0,0 +1,1167 @@++{- |+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.Gtk.Objects.MenuItem+    ( ++-- * Exported types+    MenuItem(..)                            ,+    MenuItemK                               ,+    toMenuItem                              ,+    noMenuItem                              ,+++ -- * Methods+-- ** menuItemActivate+    menuItemActivate                        ,+++-- ** menuItemDeselect+    menuItemDeselect                        ,+++-- ** menuItemGetAccelPath+    menuItemGetAccelPath                    ,+++-- ** menuItemGetLabel+    menuItemGetLabel                        ,+++-- ** menuItemGetReserveIndicator+    menuItemGetReserveIndicator             ,+++-- ** menuItemGetRightJustified+    menuItemGetRightJustified               ,+++-- ** menuItemGetSubmenu+    menuItemGetSubmenu                      ,+++-- ** menuItemGetUseUnderline+    menuItemGetUseUnderline                 ,+++-- ** menuItemNew+    menuItemNew                             ,+++-- ** menuItemNewWithLabel+    menuItemNewWithLabel                    ,+++-- ** menuItemNewWithMnemonic+    menuItemNewWithMnemonic                 ,+++-- ** menuItemSelect+    menuItemSelect                          ,+++-- ** menuItemSetAccelPath+    menuItemSetAccelPath                    ,+++-- ** menuItemSetLabel+    menuItemSetLabel                        ,+++-- ** menuItemSetReserveIndicator+    menuItemSetReserveIndicator             ,+++-- ** menuItemSetRightJustified+    menuItemSetRightJustified               ,+++-- ** menuItemSetSubmenu+    menuItemSetSubmenu                      ,+++-- ** menuItemSetUseUnderline+    menuItemSetUseUnderline                 ,+++-- ** menuItemToggleSizeAllocate+    menuItemToggleSizeAllocate              ,+++-- ** menuItemToggleSizeRequest+    menuItemToggleSizeRequest               ,+++++ -- * Properties+-- ** AccelPath+    MenuItemAccelPathPropertyInfo           ,+    constructMenuItemAccelPath              ,+    getMenuItemAccelPath                    ,+    setMenuItemAccelPath                    ,+++-- ** Label+    MenuItemLabelPropertyInfo               ,+    constructMenuItemLabel                  ,+    getMenuItemLabel                        ,+    setMenuItemLabel                        ,+++-- ** RightJustified+    MenuItemRightJustifiedPropertyInfo      ,+    constructMenuItemRightJustified         ,+    getMenuItemRightJustified               ,+    setMenuItemRightJustified               ,+++-- ** Submenu+    MenuItemSubmenuPropertyInfo             ,+    constructMenuItemSubmenu                ,+    getMenuItemSubmenu                      ,+    setMenuItemSubmenu                      ,+++-- ** UseUnderline+    MenuItemUseUnderlinePropertyInfo        ,+    constructMenuItemUseUnderline           ,+    getMenuItemUseUnderline                 ,+    setMenuItemUseUnderline                 ,+++++ -- * Signals+-- ** Activate+    MenuItemActivateCallback                ,+    MenuItemActivateCallbackC               ,+    MenuItemActivateSignalInfo              ,+    afterMenuItemActivate                   ,+    menuItemActivateCallbackWrapper         ,+    menuItemActivateClosure                 ,+    mkMenuItemActivateCallback              ,+    noMenuItemActivateCallback              ,+    onMenuItemActivate                      ,+++-- ** ActivateItem+    MenuItemActivateItemCallback            ,+    MenuItemActivateItemCallbackC           ,+    MenuItemActivateItemSignalInfo          ,+    afterMenuItemActivateItem               ,+    menuItemActivateItemCallbackWrapper     ,+    menuItemActivateItemClosure             ,+    mkMenuItemActivateItemCallback          ,+    noMenuItemActivateItemCallback          ,+    onMenuItemActivateItem                  ,+++-- ** Deselect+    MenuItemDeselectCallback                ,+    MenuItemDeselectCallbackC               ,+    MenuItemDeselectSignalInfo              ,+    afterMenuItemDeselect                   ,+    menuItemDeselectCallbackWrapper         ,+    menuItemDeselectClosure                 ,+    mkMenuItemDeselectCallback              ,+    noMenuItemDeselectCallback              ,+    onMenuItemDeselect                      ,+++-- ** Select+    MenuItemSelectCallback                  ,+    MenuItemSelectCallbackC                 ,+    MenuItemSelectSignalInfo                ,+    afterMenuItemSelect                     ,+    menuItemSelectCallbackWrapper           ,+    menuItemSelectClosure                   ,+    mkMenuItemSelectCallback                ,+    noMenuItemSelectCallback                ,+    onMenuItemSelect                        ,+++-- ** ToggleSizeAllocate+    MenuItemToggleSizeAllocateCallback      ,+    MenuItemToggleSizeAllocateCallbackC     ,+    MenuItemToggleSizeAllocateSignalInfo    ,+    afterMenuItemToggleSizeAllocate         ,+    menuItemToggleSizeAllocateCallbackWrapper,+    menuItemToggleSizeAllocateClosure       ,+    mkMenuItemToggleSizeAllocateCallback    ,+    noMenuItemToggleSizeAllocateCallback    ,+    onMenuItemToggleSizeAllocate            ,+++-- ** ToggleSizeRequest+    MenuItemToggleSizeRequestCallback       ,+    MenuItemToggleSizeRequestCallbackC      ,+    MenuItemToggleSizeRequestSignalInfo     ,+    afterMenuItemToggleSizeRequest          ,+    menuItemToggleSizeRequestCallbackWrapper,+    menuItemToggleSizeRequestClosure        ,+    mkMenuItemToggleSizeRequestCallback     ,+    noMenuItemToggleSizeRequestCallback     ,+    onMenuItemToggleSizeRequest             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuItem = MenuItem (ForeignPtr MenuItem)+foreign import ccall "gtk_menu_item_get_type"+    c_gtk_menu_item_get_type :: IO GType++type instance ParentTypes MenuItem = MenuItemParentTypes+type MenuItemParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject MenuItem where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_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++-- signal MenuItem::activate+type MenuItemActivateCallback =+    IO ()++noMenuItemActivateCallback :: Maybe MenuItemActivateCallback+noMenuItemActivateCallback = Nothing++type MenuItemActivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemActivateCallback :: MenuItemActivateCallbackC -> IO (FunPtr MenuItemActivateCallbackC)++menuItemActivateClosure :: MenuItemActivateCallback -> IO Closure+menuItemActivateClosure cb = newCClosure =<< mkMenuItemActivateCallback wrapped+    where wrapped = menuItemActivateCallbackWrapper cb++menuItemActivateCallbackWrapper ::+    MenuItemActivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuItemActivateCallbackWrapper _cb _ _ = do+    _cb ++onMenuItemActivate :: (GObject a, MonadIO m) => a -> MenuItemActivateCallback -> m SignalHandlerId+onMenuItemActivate obj cb = liftIO $ connectMenuItemActivate obj cb SignalConnectBefore+afterMenuItemActivate :: (GObject a, MonadIO m) => a -> MenuItemActivateCallback -> m SignalHandlerId+afterMenuItemActivate obj cb = connectMenuItemActivate obj cb SignalConnectAfter++connectMenuItemActivate :: (GObject a, MonadIO m) =>+                           a -> MenuItemActivateCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemActivate obj cb after = liftIO $ do+    cb' <- mkMenuItemActivateCallback (menuItemActivateCallbackWrapper cb)+    connectSignalFunPtr obj "activate" cb' after++-- signal MenuItem::activate-item+type MenuItemActivateItemCallback =+    IO ()++noMenuItemActivateItemCallback :: Maybe MenuItemActivateItemCallback+noMenuItemActivateItemCallback = Nothing++type MenuItemActivateItemCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemActivateItemCallback :: MenuItemActivateItemCallbackC -> IO (FunPtr MenuItemActivateItemCallbackC)++menuItemActivateItemClosure :: MenuItemActivateItemCallback -> IO Closure+menuItemActivateItemClosure cb = newCClosure =<< mkMenuItemActivateItemCallback wrapped+    where wrapped = menuItemActivateItemCallbackWrapper cb++menuItemActivateItemCallbackWrapper ::+    MenuItemActivateItemCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuItemActivateItemCallbackWrapper _cb _ _ = do+    _cb ++onMenuItemActivateItem :: (GObject a, MonadIO m) => a -> MenuItemActivateItemCallback -> m SignalHandlerId+onMenuItemActivateItem obj cb = liftIO $ connectMenuItemActivateItem obj cb SignalConnectBefore+afterMenuItemActivateItem :: (GObject a, MonadIO m) => a -> MenuItemActivateItemCallback -> m SignalHandlerId+afterMenuItemActivateItem obj cb = connectMenuItemActivateItem obj cb SignalConnectAfter++connectMenuItemActivateItem :: (GObject a, MonadIO m) =>+                               a -> MenuItemActivateItemCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemActivateItem obj cb after = liftIO $ do+    cb' <- mkMenuItemActivateItemCallback (menuItemActivateItemCallbackWrapper cb)+    connectSignalFunPtr obj "activate-item" cb' after++-- signal MenuItem::deselect+type MenuItemDeselectCallback =+    IO ()++noMenuItemDeselectCallback :: Maybe MenuItemDeselectCallback+noMenuItemDeselectCallback = Nothing++type MenuItemDeselectCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemDeselectCallback :: MenuItemDeselectCallbackC -> IO (FunPtr MenuItemDeselectCallbackC)++menuItemDeselectClosure :: MenuItemDeselectCallback -> IO Closure+menuItemDeselectClosure cb = newCClosure =<< mkMenuItemDeselectCallback wrapped+    where wrapped = menuItemDeselectCallbackWrapper cb++menuItemDeselectCallbackWrapper ::+    MenuItemDeselectCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuItemDeselectCallbackWrapper _cb _ _ = do+    _cb ++onMenuItemDeselect :: (GObject a, MonadIO m) => a -> MenuItemDeselectCallback -> m SignalHandlerId+onMenuItemDeselect obj cb = liftIO $ connectMenuItemDeselect obj cb SignalConnectBefore+afterMenuItemDeselect :: (GObject a, MonadIO m) => a -> MenuItemDeselectCallback -> m SignalHandlerId+afterMenuItemDeselect obj cb = connectMenuItemDeselect obj cb SignalConnectAfter++connectMenuItemDeselect :: (GObject a, MonadIO m) =>+                           a -> MenuItemDeselectCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemDeselect obj cb after = liftIO $ do+    cb' <- mkMenuItemDeselectCallback (menuItemDeselectCallbackWrapper cb)+    connectSignalFunPtr obj "deselect" cb' after++-- signal MenuItem::select+type MenuItemSelectCallback =+    IO ()++noMenuItemSelectCallback :: Maybe MenuItemSelectCallback+noMenuItemSelectCallback = Nothing++type MenuItemSelectCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemSelectCallback :: MenuItemSelectCallbackC -> IO (FunPtr MenuItemSelectCallbackC)++menuItemSelectClosure :: MenuItemSelectCallback -> IO Closure+menuItemSelectClosure cb = newCClosure =<< mkMenuItemSelectCallback wrapped+    where wrapped = menuItemSelectCallbackWrapper cb++menuItemSelectCallbackWrapper ::+    MenuItemSelectCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuItemSelectCallbackWrapper _cb _ _ = do+    _cb ++onMenuItemSelect :: (GObject a, MonadIO m) => a -> MenuItemSelectCallback -> m SignalHandlerId+onMenuItemSelect obj cb = liftIO $ connectMenuItemSelect obj cb SignalConnectBefore+afterMenuItemSelect :: (GObject a, MonadIO m) => a -> MenuItemSelectCallback -> m SignalHandlerId+afterMenuItemSelect obj cb = connectMenuItemSelect obj cb SignalConnectAfter++connectMenuItemSelect :: (GObject a, MonadIO m) =>+                         a -> MenuItemSelectCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemSelect obj cb after = liftIO $ do+    cb' <- mkMenuItemSelectCallback (menuItemSelectCallbackWrapper cb)+    connectSignalFunPtr obj "select" cb' after++-- signal MenuItem::toggle-size-allocate+type MenuItemToggleSizeAllocateCallback =+    Int32 ->+    IO ()++noMenuItemToggleSizeAllocateCallback :: Maybe MenuItemToggleSizeAllocateCallback+noMenuItemToggleSizeAllocateCallback = Nothing++type MenuItemToggleSizeAllocateCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemToggleSizeAllocateCallback :: MenuItemToggleSizeAllocateCallbackC -> IO (FunPtr MenuItemToggleSizeAllocateCallbackC)++menuItemToggleSizeAllocateClosure :: MenuItemToggleSizeAllocateCallback -> IO Closure+menuItemToggleSizeAllocateClosure cb = newCClosure =<< mkMenuItemToggleSizeAllocateCallback wrapped+    where wrapped = menuItemToggleSizeAllocateCallbackWrapper cb++menuItemToggleSizeAllocateCallbackWrapper ::+    MenuItemToggleSizeAllocateCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO ()+menuItemToggleSizeAllocateCallbackWrapper _cb _ object _ = do+    _cb  object++onMenuItemToggleSizeAllocate :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeAllocateCallback -> m SignalHandlerId+onMenuItemToggleSizeAllocate obj cb = liftIO $ connectMenuItemToggleSizeAllocate obj cb SignalConnectBefore+afterMenuItemToggleSizeAllocate :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeAllocateCallback -> m SignalHandlerId+afterMenuItemToggleSizeAllocate obj cb = connectMenuItemToggleSizeAllocate obj cb SignalConnectAfter++connectMenuItemToggleSizeAllocate :: (GObject a, MonadIO m) =>+                                     a -> MenuItemToggleSizeAllocateCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemToggleSizeAllocate obj cb after = liftIO $ do+    cb' <- mkMenuItemToggleSizeAllocateCallback (menuItemToggleSizeAllocateCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-size-allocate" cb' after++-- signal MenuItem::toggle-size-request+type MenuItemToggleSizeRequestCallback =+    Ptr () ->+    IO ()++noMenuItemToggleSizeRequestCallback :: Maybe MenuItemToggleSizeRequestCallback+noMenuItemToggleSizeRequestCallback = Nothing++type MenuItemToggleSizeRequestCallbackC =+    Ptr () ->                               -- object+    Ptr () ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuItemToggleSizeRequestCallback :: MenuItemToggleSizeRequestCallbackC -> IO (FunPtr MenuItemToggleSizeRequestCallbackC)++menuItemToggleSizeRequestClosure :: MenuItemToggleSizeRequestCallback -> IO Closure+menuItemToggleSizeRequestClosure cb = newCClosure =<< mkMenuItemToggleSizeRequestCallback wrapped+    where wrapped = menuItemToggleSizeRequestCallbackWrapper cb++menuItemToggleSizeRequestCallbackWrapper ::+    MenuItemToggleSizeRequestCallback ->+    Ptr () ->+    Ptr () ->+    Ptr () ->+    IO ()+menuItemToggleSizeRequestCallbackWrapper _cb _ object _ = do+    _cb  object++onMenuItemToggleSizeRequest :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeRequestCallback -> m SignalHandlerId+onMenuItemToggleSizeRequest obj cb = liftIO $ connectMenuItemToggleSizeRequest obj cb SignalConnectBefore+afterMenuItemToggleSizeRequest :: (GObject a, MonadIO m) => a -> MenuItemToggleSizeRequestCallback -> m SignalHandlerId+afterMenuItemToggleSizeRequest obj cb = connectMenuItemToggleSizeRequest obj cb SignalConnectAfter++connectMenuItemToggleSizeRequest :: (GObject a, MonadIO m) =>+                                    a -> MenuItemToggleSizeRequestCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuItemToggleSizeRequest obj cb after = liftIO $ do+    cb' <- mkMenuItemToggleSizeRequestCallback (menuItemToggleSizeRequestCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-size-request" cb' after++-- VVV Prop "accel-path"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuItemAccelPath :: (MonadIO m, MenuItemK o) => o -> m T.Text+getMenuItemAccelPath obj = liftIO $ getObjectPropertyString obj "accel-path"++setMenuItemAccelPath :: (MonadIO m, MenuItemK o) => o -> T.Text -> m ()+setMenuItemAccelPath obj val = liftIO $ setObjectPropertyString obj "accel-path" val++constructMenuItemAccelPath :: T.Text -> IO ([Char], GValue)+constructMenuItemAccelPath val = constructObjectPropertyString "accel-path" val++data MenuItemAccelPathPropertyInfo+instance AttrInfo MenuItemAccelPathPropertyInfo where+    type AttrAllowedOps MenuItemAccelPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuItemAccelPathPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuItemAccelPathPropertyInfo = MenuItemK+    type AttrGetType MenuItemAccelPathPropertyInfo = T.Text+    type AttrLabel MenuItemAccelPathPropertyInfo = "MenuItem::accel-path"+    attrGet _ = getMenuItemAccelPath+    attrSet _ = setMenuItemAccelPath+    attrConstruct _ = constructMenuItemAccelPath++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuItemLabel :: (MonadIO m, MenuItemK o) => o -> m T.Text+getMenuItemLabel obj = liftIO $ getObjectPropertyString obj "label"++setMenuItemLabel :: (MonadIO m, MenuItemK o) => o -> T.Text -> m ()+setMenuItemLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructMenuItemLabel :: T.Text -> IO ([Char], GValue)+constructMenuItemLabel val = constructObjectPropertyString "label" val++data MenuItemLabelPropertyInfo+instance AttrInfo MenuItemLabelPropertyInfo where+    type AttrAllowedOps MenuItemLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuItemLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MenuItemLabelPropertyInfo = MenuItemK+    type AttrGetType MenuItemLabelPropertyInfo = T.Text+    type AttrLabel MenuItemLabelPropertyInfo = "MenuItem::label"+    attrGet _ = getMenuItemLabel+    attrSet _ = setMenuItemLabel+    attrConstruct _ = constructMenuItemLabel++-- VVV Prop "right-justified"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuItemRightJustified :: (MonadIO m, MenuItemK o) => o -> m Bool+getMenuItemRightJustified obj = liftIO $ getObjectPropertyBool obj "right-justified"++setMenuItemRightJustified :: (MonadIO m, MenuItemK o) => o -> Bool -> m ()+setMenuItemRightJustified obj val = liftIO $ setObjectPropertyBool obj "right-justified" val++constructMenuItemRightJustified :: Bool -> IO ([Char], GValue)+constructMenuItemRightJustified val = constructObjectPropertyBool "right-justified" val++data MenuItemRightJustifiedPropertyInfo+instance AttrInfo MenuItemRightJustifiedPropertyInfo where+    type AttrAllowedOps MenuItemRightJustifiedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuItemRightJustifiedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuItemRightJustifiedPropertyInfo = MenuItemK+    type AttrGetType MenuItemRightJustifiedPropertyInfo = Bool+    type AttrLabel MenuItemRightJustifiedPropertyInfo = "MenuItem::right-justified"+    attrGet _ = getMenuItemRightJustified+    attrSet _ = setMenuItemRightJustified+    attrConstruct _ = constructMenuItemRightJustified++-- VVV Prop "submenu"+   -- Type: TInterface "Gtk" "Menu"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuItemSubmenu :: (MonadIO m, MenuItemK o) => o -> m Menu+getMenuItemSubmenu obj = liftIO $ getObjectPropertyObject obj "submenu" Menu++setMenuItemSubmenu :: (MonadIO m, MenuItemK o, MenuK a) => o -> a -> m ()+setMenuItemSubmenu obj val = liftIO $ setObjectPropertyObject obj "submenu" val++constructMenuItemSubmenu :: (MenuK a) => a -> IO ([Char], GValue)+constructMenuItemSubmenu val = constructObjectPropertyObject "submenu" val++data MenuItemSubmenuPropertyInfo+instance AttrInfo MenuItemSubmenuPropertyInfo where+    type AttrAllowedOps MenuItemSubmenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuItemSubmenuPropertyInfo = MenuK+    type AttrBaseTypeConstraint MenuItemSubmenuPropertyInfo = MenuItemK+    type AttrGetType MenuItemSubmenuPropertyInfo = Menu+    type AttrLabel MenuItemSubmenuPropertyInfo = "MenuItem::submenu"+    attrGet _ = getMenuItemSubmenu+    attrSet _ = setMenuItemSubmenu+    attrConstruct _ = constructMenuItemSubmenu++-- VVV Prop "use-underline"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuItemUseUnderline :: (MonadIO m, MenuItemK o) => o -> m Bool+getMenuItemUseUnderline obj = liftIO $ getObjectPropertyBool obj "use-underline"++setMenuItemUseUnderline :: (MonadIO m, MenuItemK o) => o -> Bool -> m ()+setMenuItemUseUnderline obj val = liftIO $ setObjectPropertyBool obj "use-underline" val++constructMenuItemUseUnderline :: Bool -> IO ([Char], GValue)+constructMenuItemUseUnderline val = constructObjectPropertyBool "use-underline" val++data MenuItemUseUnderlinePropertyInfo+instance AttrInfo MenuItemUseUnderlinePropertyInfo where+    type AttrAllowedOps MenuItemUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuItemUseUnderlinePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuItemUseUnderlinePropertyInfo = MenuItemK+    type AttrGetType MenuItemUseUnderlinePropertyInfo = Bool+    type AttrLabel MenuItemUseUnderlinePropertyInfo = "MenuItem::use-underline"+    attrGet _ = getMenuItemUseUnderline+    attrSet _ = setMenuItemUseUnderline+    attrConstruct _ = constructMenuItemUseUnderline++type instance AttributeList MenuItem = MenuItemAttributeList+type MenuItemAttributeList = ('[ '("accel-path", MenuItemAccelPathPropertyInfo), '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", MenuItemLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("right-justified", MenuItemRightJustifiedPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("submenu", MenuItemSubmenuPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-underline", MenuItemUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data MenuItemActivateSignalInfo+instance SignalInfo MenuItemActivateSignalInfo where+    type HaskellCallbackType MenuItemActivateSignalInfo = MenuItemActivateCallback+    connectSignal _ = connectMenuItemActivate++data MenuItemActivateItemSignalInfo+instance SignalInfo MenuItemActivateItemSignalInfo where+    type HaskellCallbackType MenuItemActivateItemSignalInfo = MenuItemActivateItemCallback+    connectSignal _ = connectMenuItemActivateItem++data MenuItemDeselectSignalInfo+instance SignalInfo MenuItemDeselectSignalInfo where+    type HaskellCallbackType MenuItemDeselectSignalInfo = MenuItemDeselectCallback+    connectSignal _ = connectMenuItemDeselect++data MenuItemSelectSignalInfo+instance SignalInfo MenuItemSelectSignalInfo where+    type HaskellCallbackType MenuItemSelectSignalInfo = MenuItemSelectCallback+    connectSignal _ = connectMenuItemSelect++data MenuItemToggleSizeAllocateSignalInfo+instance SignalInfo MenuItemToggleSizeAllocateSignalInfo where+    type HaskellCallbackType MenuItemToggleSizeAllocateSignalInfo = MenuItemToggleSizeAllocateCallback+    connectSignal _ = connectMenuItemToggleSizeAllocate++data MenuItemToggleSizeRequestSignalInfo+instance SignalInfo MenuItemToggleSizeRequestSignalInfo where+    type HaskellCallbackType MenuItemToggleSizeRequestSignalInfo = MenuItemToggleSizeRequestCallback+    connectSignal _ = connectMenuItemToggleSizeRequest++type instance SignalList MenuItem = MenuItemSignalList+type MenuItemSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", MenuItemActivateSignalInfo), '("activate-item", MenuItemActivateItemSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("deselect", MenuItemDeselectSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select", MenuItemSelectSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-size-allocate", MenuItemToggleSizeAllocateSignalInfo), '("toggle-size-request", MenuItemToggleSizeRequestSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuItem::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_new" gtk_menu_item_new :: +    IO (Ptr MenuItem)+++menuItemNew ::+    (MonadIO m) =>+    m MenuItem+menuItemNew  = liftIO $ do+    result <- gtk_menu_item_new+    checkUnexpectedReturnNULL "gtk_menu_item_new" result+    result' <- (newObject MenuItem) result+    return result'++-- method MenuItem::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_new_with_label" gtk_menu_item_new_with_label :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr MenuItem)+++menuItemNewWithLabel ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m MenuItem+menuItemNewWithLabel label = liftIO $ do+    label' <- textToCString label+    result <- gtk_menu_item_new_with_label label'+    checkUnexpectedReturnNULL "gtk_menu_item_new_with_label" result+    result' <- (newObject MenuItem) result+    freeMem label'+    return result'++-- method MenuItem::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_new_with_mnemonic" gtk_menu_item_new_with_mnemonic :: +    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr MenuItem)+++menuItemNewWithMnemonic ::+    (MonadIO m) =>+    T.Text ->                               -- label+    m MenuItem+menuItemNewWithMnemonic label = liftIO $ do+    label' <- textToCString label+    result <- gtk_menu_item_new_with_mnemonic label'+    checkUnexpectedReturnNULL "gtk_menu_item_new_with_mnemonic" result+    result' <- (newObject MenuItem) result+    freeMem label'+    return result'++-- method MenuItem::activate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_activate" gtk_menu_item_activate :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO ()+++menuItemActivate ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m ()+menuItemActivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_item_activate _obj'+    touchManagedPtr _obj+    return ()++-- method MenuItem::deselect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_deselect" gtk_menu_item_deselect :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO ()+++menuItemDeselect ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m ()+menuItemDeselect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_item_deselect _obj'+    touchManagedPtr _obj+    return ()++-- method MenuItem::get_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_accel_path" gtk_menu_item_get_accel_path :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO CString+++menuItemGetAccelPath ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m T.Text+menuItemGetAccelPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_accel_path _obj'+    checkUnexpectedReturnNULL "gtk_menu_item_get_accel_path" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MenuItem::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_label" gtk_menu_item_get_label :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO CString+++menuItemGetLabel ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m T.Text+menuItemGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_label _obj'+    checkUnexpectedReturnNULL "gtk_menu_item_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method MenuItem::get_reserve_indicator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_reserve_indicator" gtk_menu_item_get_reserve_indicator :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO CInt+++menuItemGetReserveIndicator ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m Bool+menuItemGetReserveIndicator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_reserve_indicator _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuItem::get_right_justified+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_right_justified" gtk_menu_item_get_right_justified :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO CInt++{-# DEPRECATED menuItemGetRightJustified ["(Since version 3.2)","See gtk_menu_item_set_right_justified()"]#-}+menuItemGetRightJustified ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m Bool+menuItemGetRightJustified _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_right_justified _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuItem::get_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_submenu" gtk_menu_item_get_submenu :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO (Ptr Widget)+++menuItemGetSubmenu ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m Widget+menuItemGetSubmenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_submenu _obj'+    checkUnexpectedReturnNULL "gtk_menu_item_get_submenu" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MenuItem::get_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_get_use_underline" gtk_menu_item_get_use_underline :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO CInt+++menuItemGetUseUnderline ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m Bool+menuItemGetUseUnderline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_item_get_use_underline _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuItem::select+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_select" gtk_menu_item_select :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    IO ()+++menuItemSelect ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    m ()+menuItemSelect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_item_select _obj'+    touchManagedPtr _obj+    return ()++-- method MenuItem::set_accel_path+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "accel_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 "gtk_menu_item_set_accel_path" gtk_menu_item_set_accel_path :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    CString ->                              -- accel_path : TBasicType TUTF8+    IO ()+++menuItemSetAccelPath ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- accel_path+    m ()+menuItemSetAccelPath _obj accel_path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeAccel_path <- case accel_path of+        Nothing -> return nullPtr+        Just jAccel_path -> do+            jAccel_path' <- textToCString jAccel_path+            return jAccel_path'+    gtk_menu_item_set_accel_path _obj' maybeAccel_path+    touchManagedPtr _obj+    freeMem maybeAccel_path+    return ()++-- method MenuItem::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_set_label" gtk_menu_item_set_label :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++menuItemSetLabel ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    m ()+menuItemSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    gtk_menu_item_set_label _obj' label'+    touchManagedPtr _obj+    freeMem label'+    return ()++-- method MenuItem::set_reserve_indicator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reserve", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reserve", 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 "gtk_menu_item_set_reserve_indicator" gtk_menu_item_set_reserve_indicator :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    CInt ->                                 -- reserve : TBasicType TBoolean+    IO ()+++menuItemSetReserveIndicator ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- reserve+    m ()+menuItemSetReserveIndicator _obj reserve = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let reserve' = (fromIntegral . fromEnum) reserve+    gtk_menu_item_set_reserve_indicator _obj' reserve'+    touchManagedPtr _obj+    return ()++-- method MenuItem::set_right_justified+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "right_justified", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "right_justified", 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 "gtk_menu_item_set_right_justified" gtk_menu_item_set_right_justified :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    CInt ->                                 -- right_justified : TBasicType TBoolean+    IO ()++{-# DEPRECATED menuItemSetRightJustified ["(Since version 3.2)","If you insist on using it, use","  gtk_widget_set_hexpand() and gtk_widget_set_halign()."]#-}+menuItemSetRightJustified ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- right_justified+    m ()+menuItemSetRightJustified _obj right_justified = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let right_justified' = (fromIntegral . fromEnum) right_justified+    gtk_menu_item_set_right_justified _obj' right_justified'+    touchManagedPtr _obj+    return ()++-- method MenuItem::set_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "submenu", argType = TInterface "Gtk" "Menu", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_set_submenu" gtk_menu_item_set_submenu :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    Ptr Menu ->                             -- submenu : TInterface "Gtk" "Menu"+    IO ()+++menuItemSetSubmenu ::+    (MonadIO m, MenuItemK a, MenuK 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'+    gtk_menu_item_set_submenu _obj' maybeSubmenu+    touchManagedPtr _obj+    whenJust submenu touchManagedPtr+    return ()++-- method MenuItem::set_use_underline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_menu_item_set_use_underline" gtk_menu_item_set_use_underline :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++menuItemSetUseUnderline ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+menuItemSetUseUnderline _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_menu_item_set_use_underline _obj' setting'+    touchManagedPtr _obj+    return ()++-- method MenuItem::toggle_size_allocate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allocation", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allocation", 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 "gtk_menu_item_toggle_size_allocate" gtk_menu_item_toggle_size_allocate :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    Int32 ->                                -- allocation : TBasicType TInt32+    IO ()+++menuItemToggleSizeAllocate ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- allocation+    m ()+menuItemToggleSizeAllocate _obj allocation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_item_toggle_size_allocate _obj' allocation+    touchManagedPtr _obj+    return ()++-- method MenuItem::toggle_size_request+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "requisition", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "requisition", argType = TBasicType TInt32, direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_item_toggle_size_request" gtk_menu_item_toggle_size_request :: +    Ptr MenuItem ->                         -- _obj : TInterface "Gtk" "MenuItem"+    Ptr Int32 ->                            -- requisition : TBasicType TInt32+    IO ()+++menuItemToggleSizeRequest ::+    (MonadIO m, MenuItemK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- requisition+    m (Int32)+menuItemToggleSizeRequest _obj requisition = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    requisition' <- allocMem :: IO (Ptr Int32)+    poke requisition' requisition+    gtk_menu_item_toggle_size_request _obj' requisition'+    requisition'' <- peek requisition'+    touchManagedPtr _obj+    freeMem requisition'+    return requisition''++
+ GI/Gtk/Objects/MenuItem.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gtk.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+data MenuItemAccelPathPropertyInfo+data MenuItemLabelPropertyInfo+data MenuItemRightJustifiedPropertyInfo+data MenuItemSubmenuPropertyInfo+data MenuItemUseUnderlinePropertyInfo+data MenuItemActivateSignalInfo+data MenuItemActivateItemSignalInfo+data MenuItemDeselectSignalInfo+data MenuItemSelectSignalInfo+data MenuItemToggleSizeAllocateSignalInfo+data MenuItemToggleSizeRequestSignalInfo
+ GI/Gtk/Objects/MenuItemAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.MenuItemAccessible+    ( ++-- * Exported types+    MenuItemAccessible(..)                  ,+    MenuItemAccessibleK                     ,+    toMenuItemAccessible                    ,+    noMenuItemAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuItemAccessible = MenuItemAccessible (ForeignPtr MenuItemAccessible)+foreign import ccall "gtk_menu_item_accessible_get_type"+    c_gtk_menu_item_accessible_get_type :: IO GType++type instance ParentTypes MenuItemAccessible = MenuItemAccessibleParentTypes+type MenuItemAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Selection]++instance GObject MenuItemAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_menu_item_accessible_get_type+    ++class GObject o => MenuItemAccessibleK o+instance (GObject o, IsDescendantOf MenuItemAccessible o) => MenuItemAccessibleK o++toMenuItemAccessible :: MenuItemAccessibleK o => o -> IO MenuItemAccessible+toMenuItemAccessible = unsafeCastTo MenuItemAccessible++noMenuItemAccessible :: Maybe MenuItemAccessible+noMenuItemAccessible = Nothing++type instance AttributeList MenuItemAccessible = MenuItemAccessibleAttributeList+type MenuItemAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuItemAccessible = MenuItemAccessibleSignalList+type MenuItemAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/MenuItemAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.MenuItemAccessible where++import Prelude ()+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 MenuItemAccessible = MenuItemAccessible (ForeignPtr MenuItemAccessible)+instance GObject MenuItemAccessible where+class GObject o => MenuItemAccessibleK o+instance (GObject o, IsDescendantOf MenuItemAccessible o) => MenuItemAccessibleK o
+ GI/Gtk/Objects/MenuShell.hs view
@@ -0,0 +1,1011 @@++{- |+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.Gtk.Objects.MenuShell+    ( ++-- * Exported types+    MenuShell(..)                           ,+    MenuShellK                              ,+    toMenuShell                             ,+    noMenuShell                             ,+++ -- * Methods+-- ** menuShellActivateItem+    menuShellActivateItem                   ,+++-- ** menuShellAppend+    menuShellAppend                         ,+++-- ** menuShellBindModel+    menuShellBindModel                      ,+++-- ** menuShellCancel+    menuShellCancel                         ,+++-- ** menuShellDeactivate+    menuShellDeactivate                     ,+++-- ** menuShellDeselect+    menuShellDeselect                       ,+++-- ** menuShellGetParentShell+    menuShellGetParentShell                 ,+++-- ** menuShellGetSelectedItem+    menuShellGetSelectedItem                ,+++-- ** menuShellGetTakeFocus+    menuShellGetTakeFocus                   ,+++-- ** menuShellInsert+    menuShellInsert                         ,+++-- ** menuShellPrepend+    menuShellPrepend                        ,+++-- ** menuShellSelectFirst+    menuShellSelectFirst                    ,+++-- ** menuShellSelectItem+    menuShellSelectItem                     ,+++-- ** menuShellSetTakeFocus+    menuShellSetTakeFocus                   ,+++++ -- * Properties+-- ** TakeFocus+    MenuShellTakeFocusPropertyInfo          ,+    constructMenuShellTakeFocus             ,+    getMenuShellTakeFocus                   ,+    setMenuShellTakeFocus                   ,+++++ -- * Signals+-- ** ActivateCurrent+    MenuShellActivateCurrentCallback        ,+    MenuShellActivateCurrentCallbackC       ,+    MenuShellActivateCurrentSignalInfo      ,+    afterMenuShellActivateCurrent           ,+    menuShellActivateCurrentCallbackWrapper ,+    menuShellActivateCurrentClosure         ,+    mkMenuShellActivateCurrentCallback      ,+    noMenuShellActivateCurrentCallback      ,+    onMenuShellActivateCurrent              ,+++-- ** Cancel+    MenuShellCancelCallback                 ,+    MenuShellCancelCallbackC                ,+    MenuShellCancelSignalInfo               ,+    afterMenuShellCancel                    ,+    menuShellCancelCallbackWrapper          ,+    menuShellCancelClosure                  ,+    mkMenuShellCancelCallback               ,+    noMenuShellCancelCallback               ,+    onMenuShellCancel                       ,+++-- ** CycleFocus+    MenuShellCycleFocusCallback             ,+    MenuShellCycleFocusCallbackC            ,+    MenuShellCycleFocusSignalInfo           ,+    afterMenuShellCycleFocus                ,+    menuShellCycleFocusCallbackWrapper      ,+    menuShellCycleFocusClosure              ,+    mkMenuShellCycleFocusCallback           ,+    noMenuShellCycleFocusCallback           ,+    onMenuShellCycleFocus                   ,+++-- ** Deactivate+    MenuShellDeactivateCallback             ,+    MenuShellDeactivateCallbackC            ,+    MenuShellDeactivateSignalInfo           ,+    afterMenuShellDeactivate                ,+    menuShellDeactivateCallbackWrapper      ,+    menuShellDeactivateClosure              ,+    mkMenuShellDeactivateCallback           ,+    noMenuShellDeactivateCallback           ,+    onMenuShellDeactivate                   ,+++-- ** Insert+    MenuShellInsertCallback                 ,+    MenuShellInsertCallbackC                ,+    MenuShellInsertSignalInfo               ,+    afterMenuShellInsert                    ,+    menuShellInsertCallbackWrapper          ,+    menuShellInsertClosure                  ,+    mkMenuShellInsertCallback               ,+    noMenuShellInsertCallback               ,+    onMenuShellInsert                       ,+++-- ** MoveCurrent+    MenuShellMoveCurrentCallback            ,+    MenuShellMoveCurrentCallbackC           ,+    MenuShellMoveCurrentSignalInfo          ,+    afterMenuShellMoveCurrent               ,+    menuShellMoveCurrentCallbackWrapper     ,+    menuShellMoveCurrentClosure             ,+    mkMenuShellMoveCurrentCallback          ,+    noMenuShellMoveCurrentCallback          ,+    onMenuShellMoveCurrent                  ,+++-- ** MoveSelected+    MenuShellMoveSelectedCallback           ,+    MenuShellMoveSelectedCallbackC          ,+    MenuShellMoveSelectedSignalInfo         ,+    afterMenuShellMoveSelected              ,+    menuShellMoveSelectedCallbackWrapper    ,+    menuShellMoveSelectedClosure            ,+    mkMenuShellMoveSelectedCallback         ,+    noMenuShellMoveSelectedCallback         ,+    onMenuShellMoveSelected                 ,+++-- ** SelectionDone+    MenuShellSelectionDoneCallback          ,+    MenuShellSelectionDoneCallbackC         ,+    MenuShellSelectionDoneSignalInfo        ,+    afterMenuShellSelectionDone             ,+    menuShellSelectionDoneCallbackWrapper   ,+    menuShellSelectionDoneClosure           ,+    mkMenuShellSelectionDoneCallback        ,+    noMenuShellSelectionDoneCallback        ,+    onMenuShellSelectionDone                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype MenuShell = MenuShell (ForeignPtr MenuShell)+foreign import ccall "gtk_menu_shell_get_type"+    c_gtk_menu_shell_get_type :: IO GType++type instance ParentTypes MenuShell = MenuShellParentTypes+type MenuShellParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject MenuShell where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_menu_shell_get_type+    ++class GObject o => MenuShellK o+instance (GObject o, IsDescendantOf MenuShell o) => MenuShellK o++toMenuShell :: MenuShellK o => o -> IO MenuShell+toMenuShell = unsafeCastTo MenuShell++noMenuShell :: Maybe MenuShell+noMenuShell = Nothing++-- signal MenuShell::activate-current+type MenuShellActivateCurrentCallback =+    Bool ->+    IO ()++noMenuShellActivateCurrentCallback :: Maybe MenuShellActivateCurrentCallback+noMenuShellActivateCurrentCallback = Nothing++type MenuShellActivateCurrentCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellActivateCurrentCallback :: MenuShellActivateCurrentCallbackC -> IO (FunPtr MenuShellActivateCurrentCallbackC)++menuShellActivateCurrentClosure :: MenuShellActivateCurrentCallback -> IO Closure+menuShellActivateCurrentClosure cb = newCClosure =<< mkMenuShellActivateCurrentCallback wrapped+    where wrapped = menuShellActivateCurrentCallbackWrapper cb++menuShellActivateCurrentCallbackWrapper ::+    MenuShellActivateCurrentCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO ()+menuShellActivateCurrentCallbackWrapper _cb _ force_hide _ = do+    let force_hide' = (/= 0) force_hide+    _cb  force_hide'++onMenuShellActivateCurrent :: (GObject a, MonadIO m) => a -> MenuShellActivateCurrentCallback -> m SignalHandlerId+onMenuShellActivateCurrent obj cb = liftIO $ connectMenuShellActivateCurrent obj cb SignalConnectBefore+afterMenuShellActivateCurrent :: (GObject a, MonadIO m) => a -> MenuShellActivateCurrentCallback -> m SignalHandlerId+afterMenuShellActivateCurrent obj cb = connectMenuShellActivateCurrent obj cb SignalConnectAfter++connectMenuShellActivateCurrent :: (GObject a, MonadIO m) =>+                                   a -> MenuShellActivateCurrentCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellActivateCurrent obj cb after = liftIO $ do+    cb' <- mkMenuShellActivateCurrentCallback (menuShellActivateCurrentCallbackWrapper cb)+    connectSignalFunPtr obj "activate-current" cb' after++-- signal MenuShell::cancel+type MenuShellCancelCallback =+    IO ()++noMenuShellCancelCallback :: Maybe MenuShellCancelCallback+noMenuShellCancelCallback = Nothing++type MenuShellCancelCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellCancelCallback :: MenuShellCancelCallbackC -> IO (FunPtr MenuShellCancelCallbackC)++menuShellCancelClosure :: MenuShellCancelCallback -> IO Closure+menuShellCancelClosure cb = newCClosure =<< mkMenuShellCancelCallback wrapped+    where wrapped = menuShellCancelCallbackWrapper cb++menuShellCancelCallbackWrapper ::+    MenuShellCancelCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuShellCancelCallbackWrapper _cb _ _ = do+    _cb ++onMenuShellCancel :: (GObject a, MonadIO m) => a -> MenuShellCancelCallback -> m SignalHandlerId+onMenuShellCancel obj cb = liftIO $ connectMenuShellCancel obj cb SignalConnectBefore+afterMenuShellCancel :: (GObject a, MonadIO m) => a -> MenuShellCancelCallback -> m SignalHandlerId+afterMenuShellCancel obj cb = connectMenuShellCancel obj cb SignalConnectAfter++connectMenuShellCancel :: (GObject a, MonadIO m) =>+                          a -> MenuShellCancelCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellCancel obj cb after = liftIO $ do+    cb' <- mkMenuShellCancelCallback (menuShellCancelCallbackWrapper cb)+    connectSignalFunPtr obj "cancel" cb' after++-- signal MenuShell::cycle-focus+type MenuShellCycleFocusCallback =+    DirectionType ->+    IO ()++noMenuShellCycleFocusCallback :: Maybe MenuShellCycleFocusCallback+noMenuShellCycleFocusCallback = Nothing++type MenuShellCycleFocusCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellCycleFocusCallback :: MenuShellCycleFocusCallbackC -> IO (FunPtr MenuShellCycleFocusCallbackC)++menuShellCycleFocusClosure :: MenuShellCycleFocusCallback -> IO Closure+menuShellCycleFocusClosure cb = newCClosure =<< mkMenuShellCycleFocusCallback wrapped+    where wrapped = menuShellCycleFocusCallbackWrapper cb++menuShellCycleFocusCallbackWrapper ::+    MenuShellCycleFocusCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+menuShellCycleFocusCallbackWrapper _cb _ direction _ = do+    let direction' = (toEnum . fromIntegral) direction+    _cb  direction'++onMenuShellCycleFocus :: (GObject a, MonadIO m) => a -> MenuShellCycleFocusCallback -> m SignalHandlerId+onMenuShellCycleFocus obj cb = liftIO $ connectMenuShellCycleFocus obj cb SignalConnectBefore+afterMenuShellCycleFocus :: (GObject a, MonadIO m) => a -> MenuShellCycleFocusCallback -> m SignalHandlerId+afterMenuShellCycleFocus obj cb = connectMenuShellCycleFocus obj cb SignalConnectAfter++connectMenuShellCycleFocus :: (GObject a, MonadIO m) =>+                              a -> MenuShellCycleFocusCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellCycleFocus obj cb after = liftIO $ do+    cb' <- mkMenuShellCycleFocusCallback (menuShellCycleFocusCallbackWrapper cb)+    connectSignalFunPtr obj "cycle-focus" cb' after++-- signal MenuShell::deactivate+type MenuShellDeactivateCallback =+    IO ()++noMenuShellDeactivateCallback :: Maybe MenuShellDeactivateCallback+noMenuShellDeactivateCallback = Nothing++type MenuShellDeactivateCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellDeactivateCallback :: MenuShellDeactivateCallbackC -> IO (FunPtr MenuShellDeactivateCallbackC)++menuShellDeactivateClosure :: MenuShellDeactivateCallback -> IO Closure+menuShellDeactivateClosure cb = newCClosure =<< mkMenuShellDeactivateCallback wrapped+    where wrapped = menuShellDeactivateCallbackWrapper cb++menuShellDeactivateCallbackWrapper ::+    MenuShellDeactivateCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuShellDeactivateCallbackWrapper _cb _ _ = do+    _cb ++onMenuShellDeactivate :: (GObject a, MonadIO m) => a -> MenuShellDeactivateCallback -> m SignalHandlerId+onMenuShellDeactivate obj cb = liftIO $ connectMenuShellDeactivate obj cb SignalConnectBefore+afterMenuShellDeactivate :: (GObject a, MonadIO m) => a -> MenuShellDeactivateCallback -> m SignalHandlerId+afterMenuShellDeactivate obj cb = connectMenuShellDeactivate obj cb SignalConnectAfter++connectMenuShellDeactivate :: (GObject a, MonadIO m) =>+                              a -> MenuShellDeactivateCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellDeactivate obj cb after = liftIO $ do+    cb' <- mkMenuShellDeactivateCallback (menuShellDeactivateCallbackWrapper cb)+    connectSignalFunPtr obj "deactivate" cb' after++-- signal MenuShell::insert+type MenuShellInsertCallback =+    Widget ->+    Int32 ->+    IO ()++noMenuShellInsertCallback :: Maybe MenuShellInsertCallback+noMenuShellInsertCallback = Nothing++type MenuShellInsertCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellInsertCallback :: MenuShellInsertCallbackC -> IO (FunPtr MenuShellInsertCallbackC)++menuShellInsertClosure :: MenuShellInsertCallback -> IO Closure+menuShellInsertClosure cb = newCClosure =<< mkMenuShellInsertCallback wrapped+    where wrapped = menuShellInsertCallbackWrapper cb++menuShellInsertCallbackWrapper ::+    MenuShellInsertCallback ->+    Ptr () ->+    Ptr Widget ->+    Int32 ->+    Ptr () ->+    IO ()+menuShellInsertCallbackWrapper _cb _ child position _ = do+    child' <- (newObject Widget) child+    _cb  child' position++onMenuShellInsert :: (GObject a, MonadIO m) => a -> MenuShellInsertCallback -> m SignalHandlerId+onMenuShellInsert obj cb = liftIO $ connectMenuShellInsert obj cb SignalConnectBefore+afterMenuShellInsert :: (GObject a, MonadIO m) => a -> MenuShellInsertCallback -> m SignalHandlerId+afterMenuShellInsert obj cb = connectMenuShellInsert obj cb SignalConnectAfter++connectMenuShellInsert :: (GObject a, MonadIO m) =>+                          a -> MenuShellInsertCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellInsert obj cb after = liftIO $ do+    cb' <- mkMenuShellInsertCallback (menuShellInsertCallbackWrapper cb)+    connectSignalFunPtr obj "insert" cb' after++-- signal MenuShell::move-current+type MenuShellMoveCurrentCallback =+    MenuDirectionType ->+    IO ()++noMenuShellMoveCurrentCallback :: Maybe MenuShellMoveCurrentCallback+noMenuShellMoveCurrentCallback = Nothing++type MenuShellMoveCurrentCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellMoveCurrentCallback :: MenuShellMoveCurrentCallbackC -> IO (FunPtr MenuShellMoveCurrentCallbackC)++menuShellMoveCurrentClosure :: MenuShellMoveCurrentCallback -> IO Closure+menuShellMoveCurrentClosure cb = newCClosure =<< mkMenuShellMoveCurrentCallback wrapped+    where wrapped = menuShellMoveCurrentCallbackWrapper cb++menuShellMoveCurrentCallbackWrapper ::+    MenuShellMoveCurrentCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+menuShellMoveCurrentCallbackWrapper _cb _ direction _ = do+    let direction' = (toEnum . fromIntegral) direction+    _cb  direction'++onMenuShellMoveCurrent :: (GObject a, MonadIO m) => a -> MenuShellMoveCurrentCallback -> m SignalHandlerId+onMenuShellMoveCurrent obj cb = liftIO $ connectMenuShellMoveCurrent obj cb SignalConnectBefore+afterMenuShellMoveCurrent :: (GObject a, MonadIO m) => a -> MenuShellMoveCurrentCallback -> m SignalHandlerId+afterMenuShellMoveCurrent obj cb = connectMenuShellMoveCurrent obj cb SignalConnectAfter++connectMenuShellMoveCurrent :: (GObject a, MonadIO m) =>+                               a -> MenuShellMoveCurrentCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellMoveCurrent obj cb after = liftIO $ do+    cb' <- mkMenuShellMoveCurrentCallback (menuShellMoveCurrentCallbackWrapper cb)+    connectSignalFunPtr obj "move-current" cb' after++-- signal MenuShell::move-selected+type MenuShellMoveSelectedCallback =+    Int32 ->+    IO Bool++noMenuShellMoveSelectedCallback :: Maybe MenuShellMoveSelectedCallback+noMenuShellMoveSelectedCallback = Nothing++type MenuShellMoveSelectedCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkMenuShellMoveSelectedCallback :: MenuShellMoveSelectedCallbackC -> IO (FunPtr MenuShellMoveSelectedCallbackC)++menuShellMoveSelectedClosure :: MenuShellMoveSelectedCallback -> IO Closure+menuShellMoveSelectedClosure cb = newCClosure =<< mkMenuShellMoveSelectedCallback wrapped+    where wrapped = menuShellMoveSelectedCallbackWrapper cb++menuShellMoveSelectedCallbackWrapper ::+    MenuShellMoveSelectedCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO CInt+menuShellMoveSelectedCallbackWrapper _cb _ distance _ = do+    result <- _cb  distance+    let result' = (fromIntegral . fromEnum) result+    return result'++onMenuShellMoveSelected :: (GObject a, MonadIO m) => a -> MenuShellMoveSelectedCallback -> m SignalHandlerId+onMenuShellMoveSelected obj cb = liftIO $ connectMenuShellMoveSelected obj cb SignalConnectBefore+afterMenuShellMoveSelected :: (GObject a, MonadIO m) => a -> MenuShellMoveSelectedCallback -> m SignalHandlerId+afterMenuShellMoveSelected obj cb = connectMenuShellMoveSelected obj cb SignalConnectAfter++connectMenuShellMoveSelected :: (GObject a, MonadIO m) =>+                                a -> MenuShellMoveSelectedCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellMoveSelected obj cb after = liftIO $ do+    cb' <- mkMenuShellMoveSelectedCallback (menuShellMoveSelectedCallbackWrapper cb)+    connectSignalFunPtr obj "move-selected" cb' after++-- signal MenuShell::selection-done+type MenuShellSelectionDoneCallback =+    IO ()++noMenuShellSelectionDoneCallback :: Maybe MenuShellSelectionDoneCallback+noMenuShellSelectionDoneCallback = Nothing++type MenuShellSelectionDoneCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuShellSelectionDoneCallback :: MenuShellSelectionDoneCallbackC -> IO (FunPtr MenuShellSelectionDoneCallbackC)++menuShellSelectionDoneClosure :: MenuShellSelectionDoneCallback -> IO Closure+menuShellSelectionDoneClosure cb = newCClosure =<< mkMenuShellSelectionDoneCallback wrapped+    where wrapped = menuShellSelectionDoneCallbackWrapper cb++menuShellSelectionDoneCallbackWrapper ::+    MenuShellSelectionDoneCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuShellSelectionDoneCallbackWrapper _cb _ _ = do+    _cb ++onMenuShellSelectionDone :: (GObject a, MonadIO m) => a -> MenuShellSelectionDoneCallback -> m SignalHandlerId+onMenuShellSelectionDone obj cb = liftIO $ connectMenuShellSelectionDone obj cb SignalConnectBefore+afterMenuShellSelectionDone :: (GObject a, MonadIO m) => a -> MenuShellSelectionDoneCallback -> m SignalHandlerId+afterMenuShellSelectionDone obj cb = connectMenuShellSelectionDone obj cb SignalConnectAfter++connectMenuShellSelectionDone :: (GObject a, MonadIO m) =>+                                 a -> MenuShellSelectionDoneCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuShellSelectionDone obj cb after = liftIO $ do+    cb' <- mkMenuShellSelectionDoneCallback (menuShellSelectionDoneCallbackWrapper cb)+    connectSignalFunPtr obj "selection-done" cb' after++-- VVV Prop "take-focus"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuShellTakeFocus :: (MonadIO m, MenuShellK o) => o -> m Bool+getMenuShellTakeFocus obj = liftIO $ getObjectPropertyBool obj "take-focus"++setMenuShellTakeFocus :: (MonadIO m, MenuShellK o) => o -> Bool -> m ()+setMenuShellTakeFocus obj val = liftIO $ setObjectPropertyBool obj "take-focus" val++constructMenuShellTakeFocus :: Bool -> IO ([Char], GValue)+constructMenuShellTakeFocus val = constructObjectPropertyBool "take-focus" val++data MenuShellTakeFocusPropertyInfo+instance AttrInfo MenuShellTakeFocusPropertyInfo where+    type AttrAllowedOps MenuShellTakeFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuShellTakeFocusPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MenuShellTakeFocusPropertyInfo = MenuShellK+    type AttrGetType MenuShellTakeFocusPropertyInfo = Bool+    type AttrLabel MenuShellTakeFocusPropertyInfo = "MenuShell::take-focus"+    attrGet _ = getMenuShellTakeFocus+    attrSet _ = setMenuShellTakeFocus+    attrConstruct _ = constructMenuShellTakeFocus++type instance AttributeList MenuShell = MenuShellAttributeList+type MenuShellAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("take-focus", MenuShellTakeFocusPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data MenuShellActivateCurrentSignalInfo+instance SignalInfo MenuShellActivateCurrentSignalInfo where+    type HaskellCallbackType MenuShellActivateCurrentSignalInfo = MenuShellActivateCurrentCallback+    connectSignal _ = connectMenuShellActivateCurrent++data MenuShellCancelSignalInfo+instance SignalInfo MenuShellCancelSignalInfo where+    type HaskellCallbackType MenuShellCancelSignalInfo = MenuShellCancelCallback+    connectSignal _ = connectMenuShellCancel++data MenuShellCycleFocusSignalInfo+instance SignalInfo MenuShellCycleFocusSignalInfo where+    type HaskellCallbackType MenuShellCycleFocusSignalInfo = MenuShellCycleFocusCallback+    connectSignal _ = connectMenuShellCycleFocus++data MenuShellDeactivateSignalInfo+instance SignalInfo MenuShellDeactivateSignalInfo where+    type HaskellCallbackType MenuShellDeactivateSignalInfo = MenuShellDeactivateCallback+    connectSignal _ = connectMenuShellDeactivate++data MenuShellInsertSignalInfo+instance SignalInfo MenuShellInsertSignalInfo where+    type HaskellCallbackType MenuShellInsertSignalInfo = MenuShellInsertCallback+    connectSignal _ = connectMenuShellInsert++data MenuShellMoveCurrentSignalInfo+instance SignalInfo MenuShellMoveCurrentSignalInfo where+    type HaskellCallbackType MenuShellMoveCurrentSignalInfo = MenuShellMoveCurrentCallback+    connectSignal _ = connectMenuShellMoveCurrent++data MenuShellMoveSelectedSignalInfo+instance SignalInfo MenuShellMoveSelectedSignalInfo where+    type HaskellCallbackType MenuShellMoveSelectedSignalInfo = MenuShellMoveSelectedCallback+    connectSignal _ = connectMenuShellMoveSelected++data MenuShellSelectionDoneSignalInfo+instance SignalInfo MenuShellSelectionDoneSignalInfo where+    type HaskellCallbackType MenuShellSelectionDoneSignalInfo = MenuShellSelectionDoneCallback+    connectSignal _ = connectMenuShellSelectionDone++type instance SignalList MenuShell = MenuShellSignalList+type MenuShellSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-current", MenuShellActivateCurrentSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel", MenuShellCancelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("cycle-focus", MenuShellCycleFocusSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("deactivate", MenuShellDeactivateSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("insert", MenuShellInsertSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-current", MenuShellMoveCurrentSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-selected", MenuShellMoveSelectedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-done", MenuShellSelectionDoneSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuShell::activate_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_deactivate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "force_deactivate", 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 "gtk_menu_shell_activate_item" gtk_menu_shell_activate_item :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr Widget ->                           -- menu_item : TInterface "Gtk" "Widget"+    CInt ->                                 -- force_deactivate : TBasicType TBoolean+    IO ()+++menuShellActivateItem ::+    (MonadIO m, MenuShellK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- menu_item+    Bool ->                                 -- force_deactivate+    m ()+menuShellActivateItem _obj menu_item force_deactivate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let menu_item' = unsafeManagedPtrCastPtr menu_item+    let force_deactivate' = (fromIntegral . fromEnum) force_deactivate+    gtk_menu_shell_activate_item _obj' menu_item' force_deactivate'+    touchManagedPtr _obj+    touchManagedPtr menu_item+    return ()++-- method MenuShell::append+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "MenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_append" gtk_menu_shell_append :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr MenuItem ->                         -- child : TInterface "Gtk" "MenuItem"+    IO ()+++menuShellAppend ::+    (MonadIO m, MenuShellK a, MenuItemK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+menuShellAppend _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_menu_shell_append _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method MenuShell::bind_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", 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},Arg {argName = "action_namespace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "with_separators", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", 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},Arg {argName = "action_namespace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "with_separators", 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 "gtk_menu_shell_bind_model" gtk_menu_shell_bind_model :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr Gio.MenuModel ->                    -- model : TInterface "Gio" "MenuModel"+    CString ->                              -- action_namespace : TBasicType TUTF8+    CInt ->                                 -- with_separators : TBasicType TBoolean+    IO ()+++menuShellBindModel ::+    (MonadIO m, MenuShellK a, Gio.MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    Maybe (T.Text) ->                       -- action_namespace+    Bool ->                                 -- with_separators+    m ()+menuShellBindModel _obj model action_namespace with_separators = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    maybeAction_namespace <- case action_namespace of+        Nothing -> return nullPtr+        Just jAction_namespace -> do+            jAction_namespace' <- textToCString jAction_namespace+            return jAction_namespace'+    let with_separators' = (fromIntegral . fromEnum) with_separators+    gtk_menu_shell_bind_model _obj' maybeModel maybeAction_namespace with_separators'+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    freeMem maybeAction_namespace+    return ()++-- method MenuShell::cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_cancel" gtk_menu_shell_cancel :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO ()+++menuShellCancel ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m ()+menuShellCancel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_shell_cancel _obj'+    touchManagedPtr _obj+    return ()++-- method MenuShell::deactivate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_deactivate" gtk_menu_shell_deactivate :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO ()+++menuShellDeactivate ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m ()+menuShellDeactivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_shell_deactivate _obj'+    touchManagedPtr _obj+    return ()++-- method MenuShell::deselect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_deselect" gtk_menu_shell_deselect :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO ()+++menuShellDeselect ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m ()+menuShellDeselect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_menu_shell_deselect _obj'+    touchManagedPtr _obj+    return ()++-- method MenuShell::get_parent_shell+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_get_parent_shell" gtk_menu_shell_get_parent_shell :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO (Ptr Widget)+++menuShellGetParentShell ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m Widget+menuShellGetParentShell _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_shell_get_parent_shell _obj'+    checkUnexpectedReturnNULL "gtk_menu_shell_get_parent_shell" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MenuShell::get_selected_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_get_selected_item" gtk_menu_shell_get_selected_item :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO (Ptr Widget)+++menuShellGetSelectedItem ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m Widget+menuShellGetSelectedItem _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_shell_get_selected_item _obj'+    checkUnexpectedReturnNULL "gtk_menu_shell_get_selected_item" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MenuShell::get_take_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_get_take_focus" gtk_menu_shell_get_take_focus :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    IO CInt+++menuShellGetTakeFocus ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    m Bool+menuShellGetTakeFocus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_shell_get_take_focus _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MenuShell::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_menu_shell_insert" gtk_menu_shell_insert :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++menuShellInsert ::+    (MonadIO m, MenuShellK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+menuShellInsert _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_menu_shell_insert _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method MenuShell::prepend+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_prepend" gtk_menu_shell_prepend :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++menuShellPrepend ::+    (MonadIO m, MenuShellK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+menuShellPrepend _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_menu_shell_prepend _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method MenuShell::select_first+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "search_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "search_sensitive", 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 "gtk_menu_shell_select_first" gtk_menu_shell_select_first :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    CInt ->                                 -- search_sensitive : TBasicType TBoolean+    IO ()+++menuShellSelectFirst ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- search_sensitive+    m ()+menuShellSelectFirst _obj search_sensitive = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let search_sensitive' = (fromIntegral . fromEnum) search_sensitive+    gtk_menu_shell_select_first _obj' search_sensitive'+    touchManagedPtr _obj+    return ()++-- method MenuShell::select_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_item", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_shell_select_item" gtk_menu_shell_select_item :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    Ptr Widget ->                           -- menu_item : TInterface "Gtk" "Widget"+    IO ()+++menuShellSelectItem ::+    (MonadIO m, MenuShellK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- menu_item+    m ()+menuShellSelectItem _obj menu_item = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let menu_item' = unsafeManagedPtrCastPtr menu_item+    gtk_menu_shell_select_item _obj' menu_item'+    touchManagedPtr _obj+    touchManagedPtr menu_item+    return ()++-- method MenuShell::set_take_focus+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "take_focus", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuShell", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "take_focus", 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 "gtk_menu_shell_set_take_focus" gtk_menu_shell_set_take_focus :: +    Ptr MenuShell ->                        -- _obj : TInterface "Gtk" "MenuShell"+    CInt ->                                 -- take_focus : TBasicType TBoolean+    IO ()+++menuShellSetTakeFocus ::+    (MonadIO m, MenuShellK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- take_focus+    m ()+menuShellSetTakeFocus _obj take_focus = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let take_focus' = (fromIntegral . fromEnum) take_focus+    gtk_menu_shell_set_take_focus _obj' take_focus'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/MenuShell.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gtk.Objects.MenuShell where++import Prelude ()+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 MenuShell = MenuShell (ForeignPtr MenuShell)+instance GObject MenuShell where+class GObject o => MenuShellK o+instance (GObject o, IsDescendantOf MenuShell o) => MenuShellK o+data MenuShellTakeFocusPropertyInfo+data MenuShellActivateCurrentSignalInfo+data MenuShellCancelSignalInfo+data MenuShellCycleFocusSignalInfo+data MenuShellDeactivateSignalInfo+data MenuShellInsertSignalInfo+data MenuShellMoveCurrentSignalInfo+data MenuShellMoveSelectedSignalInfo+data MenuShellSelectionDoneSignalInfo
+ GI/Gtk/Objects/MenuShellAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.MenuShellAccessible+    ( ++-- * Exported types+    MenuShellAccessible(..)                 ,+    MenuShellAccessibleK                    ,+    toMenuShellAccessible                   ,+    noMenuShellAccessible                   ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuShellAccessible = MenuShellAccessible (ForeignPtr MenuShellAccessible)+foreign import ccall "gtk_menu_shell_accessible_get_type"+    c_gtk_menu_shell_accessible_get_type :: IO GType++type instance ParentTypes MenuShellAccessible = MenuShellAccessibleParentTypes+type MenuShellAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject MenuShellAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_menu_shell_accessible_get_type+    ++class GObject o => MenuShellAccessibleK o+instance (GObject o, IsDescendantOf MenuShellAccessible o) => MenuShellAccessibleK o++toMenuShellAccessible :: MenuShellAccessibleK o => o -> IO MenuShellAccessible+toMenuShellAccessible = unsafeCastTo MenuShellAccessible++noMenuShellAccessible :: Maybe MenuShellAccessible+noMenuShellAccessible = Nothing++type instance AttributeList MenuShellAccessible = MenuShellAccessibleAttributeList+type MenuShellAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MenuShellAccessible = MenuShellAccessibleSignalList+type MenuShellAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/MenuShellAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.MenuShellAccessible where++import Prelude ()+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 MenuShellAccessible = MenuShellAccessible (ForeignPtr MenuShellAccessible)+instance GObject MenuShellAccessible where+class GObject o => MenuShellAccessibleK o+instance (GObject o, IsDescendantOf MenuShellAccessible o) => MenuShellAccessibleK o
+ GI/Gtk/Objects/MenuToolButton.hs view
@@ -0,0 +1,352 @@++{- |+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.Gtk.Objects.MenuToolButton+    ( ++-- * Exported types+    MenuToolButton(..)                      ,+    MenuToolButtonK                         ,+    toMenuToolButton                        ,+    noMenuToolButton                        ,+++ -- * Methods+-- ** menuToolButtonGetMenu+    menuToolButtonGetMenu                   ,+++-- ** menuToolButtonNew+    menuToolButtonNew                       ,+++-- ** menuToolButtonNewFromStock+    menuToolButtonNewFromStock              ,+++-- ** menuToolButtonSetArrowTooltipMarkup+    menuToolButtonSetArrowTooltipMarkup     ,+++-- ** menuToolButtonSetArrowTooltipText+    menuToolButtonSetArrowTooltipText       ,+++-- ** menuToolButtonSetMenu+    menuToolButtonSetMenu                   ,+++++ -- * Properties+-- ** Menu+    MenuToolButtonMenuPropertyInfo          ,+    constructMenuToolButtonMenu             ,+    getMenuToolButtonMenu                   ,+    setMenuToolButtonMenu                   ,+++++ -- * Signals+-- ** ShowMenu+    MenuToolButtonShowMenuCallback          ,+    MenuToolButtonShowMenuCallbackC         ,+    MenuToolButtonShowMenuSignalInfo        ,+    afterMenuToolButtonShowMenu             ,+    menuToolButtonShowMenuCallbackWrapper   ,+    menuToolButtonShowMenuClosure           ,+    mkMenuToolButtonShowMenuCallback        ,+    noMenuToolButtonShowMenuCallback        ,+    onMenuToolButtonShowMenu                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MenuToolButton = MenuToolButton (ForeignPtr MenuToolButton)+foreign import ccall "gtk_menu_tool_button_get_type"+    c_gtk_menu_tool_button_get_type :: IO GType++type instance ParentTypes MenuToolButton = MenuToolButtonParentTypes+type MenuToolButtonParentTypes = '[ToolButton, ToolItem, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject MenuToolButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_menu_tool_button_get_type+    ++class GObject o => MenuToolButtonK o+instance (GObject o, IsDescendantOf MenuToolButton o) => MenuToolButtonK o++toMenuToolButton :: MenuToolButtonK o => o -> IO MenuToolButton+toMenuToolButton = unsafeCastTo MenuToolButton++noMenuToolButton :: Maybe MenuToolButton+noMenuToolButton = Nothing++-- signal MenuToolButton::show-menu+type MenuToolButtonShowMenuCallback =+    IO ()++noMenuToolButtonShowMenuCallback :: Maybe MenuToolButtonShowMenuCallback+noMenuToolButtonShowMenuCallback = Nothing++type MenuToolButtonShowMenuCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkMenuToolButtonShowMenuCallback :: MenuToolButtonShowMenuCallbackC -> IO (FunPtr MenuToolButtonShowMenuCallbackC)++menuToolButtonShowMenuClosure :: MenuToolButtonShowMenuCallback -> IO Closure+menuToolButtonShowMenuClosure cb = newCClosure =<< mkMenuToolButtonShowMenuCallback wrapped+    where wrapped = menuToolButtonShowMenuCallbackWrapper cb++menuToolButtonShowMenuCallbackWrapper ::+    MenuToolButtonShowMenuCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+menuToolButtonShowMenuCallbackWrapper _cb _ _ = do+    _cb ++onMenuToolButtonShowMenu :: (GObject a, MonadIO m) => a -> MenuToolButtonShowMenuCallback -> m SignalHandlerId+onMenuToolButtonShowMenu obj cb = liftIO $ connectMenuToolButtonShowMenu obj cb SignalConnectBefore+afterMenuToolButtonShowMenu :: (GObject a, MonadIO m) => a -> MenuToolButtonShowMenuCallback -> m SignalHandlerId+afterMenuToolButtonShowMenu obj cb = connectMenuToolButtonShowMenu obj cb SignalConnectAfter++connectMenuToolButtonShowMenu :: (GObject a, MonadIO m) =>+                                 a -> MenuToolButtonShowMenuCallback -> SignalConnectMode -> m SignalHandlerId+connectMenuToolButtonShowMenu obj cb after = liftIO $ do+    cb' <- mkMenuToolButtonShowMenuCallback (menuToolButtonShowMenuCallbackWrapper cb)+    connectSignalFunPtr obj "show-menu" cb' after++-- VVV Prop "menu"+   -- Type: TInterface "Gtk" "Menu"+   -- Flags: [PropertyReadable,PropertyWritable]++getMenuToolButtonMenu :: (MonadIO m, MenuToolButtonK o) => o -> m Menu+getMenuToolButtonMenu obj = liftIO $ getObjectPropertyObject obj "menu" Menu++setMenuToolButtonMenu :: (MonadIO m, MenuToolButtonK o, MenuK a) => o -> a -> m ()+setMenuToolButtonMenu obj val = liftIO $ setObjectPropertyObject obj "menu" val++constructMenuToolButtonMenu :: (MenuK a) => a -> IO ([Char], GValue)+constructMenuToolButtonMenu val = constructObjectPropertyObject "menu" val++data MenuToolButtonMenuPropertyInfo+instance AttrInfo MenuToolButtonMenuPropertyInfo where+    type AttrAllowedOps MenuToolButtonMenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MenuToolButtonMenuPropertyInfo = MenuK+    type AttrBaseTypeConstraint MenuToolButtonMenuPropertyInfo = MenuToolButtonK+    type AttrGetType MenuToolButtonMenuPropertyInfo = Menu+    type AttrLabel MenuToolButtonMenuPropertyInfo = "MenuToolButton::menu"+    attrGet _ = getMenuToolButtonMenu+    attrSet _ = setMenuToolButtonMenu+    attrConstruct _ = constructMenuToolButtonMenu++type instance AttributeList MenuToolButton = MenuToolButtonAttributeList+type MenuToolButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("icon-name", ToolButtonIconNamePropertyInfo), '("icon-widget", ToolButtonIconWidgetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-important", ToolItemIsImportantPropertyInfo), '("label", ToolButtonLabelPropertyInfo), '("label-widget", ToolButtonLabelWidgetPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("menu", MenuToolButtonMenuPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("stock-id", ToolButtonStockIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-underline", ToolButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("visible-horizontal", ToolItemVisibleHorizontalPropertyInfo), '("visible-vertical", ToolItemVisibleVerticalPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data MenuToolButtonShowMenuSignalInfo+instance SignalInfo MenuToolButtonShowMenuSignalInfo where+    type HaskellCallbackType MenuToolButtonShowMenuSignalInfo = MenuToolButtonShowMenuCallback+    connectSignal _ = connectMenuToolButtonShowMenu++type instance SignalList MenuToolButton = MenuToolButtonSignalList+type MenuToolButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ToolButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("create-menu-proxy", ToolItemCreateMenuProxySignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("show-menu", MenuToolButtonShowMenuSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toolbar-reconfigured", ToolItemToolbarReconfiguredSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MenuToolButton::new+-- method type : Constructor+-- Args : [Arg {argName = "icon_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 = "icon_widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 : TInterface "Gtk" "MenuToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_tool_button_new" gtk_menu_tool_button_new :: +    Ptr Widget ->                           -- icon_widget : TInterface "Gtk" "Widget"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr MenuToolButton)+++menuToolButtonNew ::+    (MonadIO m, WidgetK a) =>+    Maybe (a) ->                            -- icon_widget+    Maybe (T.Text) ->                       -- label+    m MenuToolButton+menuToolButtonNew icon_widget label = liftIO $ do+    maybeIcon_widget <- case icon_widget of+        Nothing -> return nullPtr+        Just jIcon_widget -> do+            let jIcon_widget' = unsafeManagedPtrCastPtr jIcon_widget+            return jIcon_widget'+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_menu_tool_button_new maybeIcon_widget maybeLabel+    checkUnexpectedReturnNULL "gtk_menu_tool_button_new" result+    result' <- (newObject MenuToolButton) result+    whenJust icon_widget touchManagedPtr+    freeMem maybeLabel+    return result'++-- method MenuToolButton::new_from_stock+-- method type : Constructor+-- Args : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MenuToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_tool_button_new_from_stock" gtk_menu_tool_button_new_from_stock :: +    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr MenuToolButton)++{-# DEPRECATED menuToolButtonNewFromStock ["(Since version 3.10)","Use gtk_menu_tool_button_new() instead."]#-}+menuToolButtonNewFromStock ::+    (MonadIO m) =>+    T.Text ->                               -- stock_id+    m MenuToolButton+menuToolButtonNewFromStock stock_id = liftIO $ do+    stock_id' <- textToCString stock_id+    result <- gtk_menu_tool_button_new_from_stock stock_id'+    checkUnexpectedReturnNULL "gtk_menu_tool_button_new_from_stock" result+    result' <- (newObject MenuToolButton) result+    freeMem stock_id'+    return result'++-- method MenuToolButton::get_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_tool_button_get_menu" gtk_menu_tool_button_get_menu :: +    Ptr MenuToolButton ->                   -- _obj : TInterface "Gtk" "MenuToolButton"+    IO (Ptr Widget)+++menuToolButtonGetMenu ::+    (MonadIO m, MenuToolButtonK a) =>+    a ->                                    -- _obj+    m Widget+menuToolButtonGetMenu _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_menu_tool_button_get_menu _obj'+    checkUnexpectedReturnNULL "gtk_menu_tool_button_get_menu" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MenuToolButton::set_arrow_tooltip_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "markup", 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 "gtk_menu_tool_button_set_arrow_tooltip_markup" gtk_menu_tool_button_set_arrow_tooltip_markup :: +    Ptr MenuToolButton ->                   -- _obj : TInterface "Gtk" "MenuToolButton"+    CString ->                              -- markup : TBasicType TUTF8+    IO ()+++menuToolButtonSetArrowTooltipMarkup ::+    (MonadIO m, MenuToolButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- markup+    m ()+menuToolButtonSetArrowTooltipMarkup _obj markup = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    markup' <- textToCString markup+    gtk_menu_tool_button_set_arrow_tooltip_markup _obj' markup'+    touchManagedPtr _obj+    freeMem markup'+    return ()++-- method MenuToolButton::set_arrow_tooltip_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_menu_tool_button_set_arrow_tooltip_text" gtk_menu_tool_button_set_arrow_tooltip_text :: +    Ptr MenuToolButton ->                   -- _obj : TInterface "Gtk" "MenuToolButton"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++menuToolButtonSetArrowTooltipText ::+    (MonadIO m, MenuToolButtonK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+menuToolButtonSetArrowTooltipText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    gtk_menu_tool_button_set_arrow_tooltip_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method MenuToolButton::set_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MenuToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_menu_tool_button_set_menu" gtk_menu_tool_button_set_menu :: +    Ptr MenuToolButton ->                   -- _obj : TInterface "Gtk" "MenuToolButton"+    Ptr Widget ->                           -- menu : TInterface "Gtk" "Widget"+    IO ()+++menuToolButtonSetMenu ::+    (MonadIO m, MenuToolButtonK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- menu+    m ()+menuToolButtonSetMenu _obj menu = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let menu' = unsafeManagedPtrCastPtr menu+    gtk_menu_tool_button_set_menu _obj' menu'+    touchManagedPtr _obj+    touchManagedPtr menu+    return ()++
+ GI/Gtk/Objects/MenuToolButton.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.MenuToolButton where++import Prelude ()+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 MenuToolButton = MenuToolButton (ForeignPtr MenuToolButton)+instance GObject MenuToolButton where+class GObject o => MenuToolButtonK o+instance (GObject o, IsDescendantOf MenuToolButton o) => MenuToolButtonK o+data MenuToolButtonMenuPropertyInfo+data MenuToolButtonShowMenuSignalInfo
+ GI/Gtk/Objects/MessageDialog.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.Gtk.Objects.MessageDialog+    ( ++-- * Exported types+    MessageDialog(..)                       ,+    MessageDialogK                          ,+    toMessageDialog                         ,+    noMessageDialog                         ,+++ -- * Methods+-- ** messageDialogGetImage+    messageDialogGetImage                   ,+++-- ** messageDialogGetMessageArea+    messageDialogGetMessageArea             ,+++-- ** messageDialogSetImage+    messageDialogSetImage                   ,+++-- ** messageDialogSetMarkup+    messageDialogSetMarkup                  ,+++++ -- * Properties+-- ** Buttons+    MessageDialogButtonsPropertyInfo        ,+    constructMessageDialogButtons           ,+++-- ** Image+    MessageDialogImagePropertyInfo          ,+    constructMessageDialogImage             ,+    getMessageDialogImage                   ,+    setMessageDialogImage                   ,+++-- ** MessageArea+    MessageDialogMessageAreaPropertyInfo    ,+    getMessageDialogMessageArea             ,+++-- ** MessageType+    MessageDialogMessageTypePropertyInfo    ,+    constructMessageDialogMessageType       ,+    getMessageDialogMessageType             ,+    setMessageDialogMessageType             ,+++-- ** SecondaryText+    MessageDialogSecondaryTextPropertyInfo  ,+    constructMessageDialogSecondaryText     ,+    getMessageDialogSecondaryText           ,+    setMessageDialogSecondaryText           ,+++-- ** SecondaryUseMarkup+    MessageDialogSecondaryUseMarkupPropertyInfo,+    constructMessageDialogSecondaryUseMarkup,+    getMessageDialogSecondaryUseMarkup      ,+    setMessageDialogSecondaryUseMarkup      ,+++-- ** Text+    MessageDialogTextPropertyInfo           ,+    constructMessageDialogText              ,+    getMessageDialogText                    ,+    setMessageDialogText                    ,+++-- ** UseMarkup+    MessageDialogUseMarkupPropertyInfo      ,+    constructMessageDialogUseMarkup         ,+    getMessageDialogUseMarkup               ,+    setMessageDialogUseMarkup               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype MessageDialog = MessageDialog (ForeignPtr MessageDialog)+foreign import ccall "gtk_message_dialog_get_type"+    c_gtk_message_dialog_get_type :: IO GType++type instance ParentTypes MessageDialog = MessageDialogParentTypes+type MessageDialogParentTypes = '[Dialog, Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject MessageDialog where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_message_dialog_get_type+    ++class GObject o => MessageDialogK o+instance (GObject o, IsDescendantOf MessageDialog o) => MessageDialogK o++toMessageDialog :: MessageDialogK o => o -> IO MessageDialog+toMessageDialog = unsafeCastTo MessageDialog++noMessageDialog :: Maybe MessageDialog+noMessageDialog = Nothing++-- VVV Prop "buttons"+   -- Type: TInterface "Gtk" "ButtonsType"+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructMessageDialogButtons :: ButtonsType -> IO ([Char], GValue)+constructMessageDialogButtons val = constructObjectPropertyEnum "buttons" val++data MessageDialogButtonsPropertyInfo+instance AttrInfo MessageDialogButtonsPropertyInfo where+    type AttrAllowedOps MessageDialogButtonsPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint MessageDialogButtonsPropertyInfo = (~) ButtonsType+    type AttrBaseTypeConstraint MessageDialogButtonsPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogButtonsPropertyInfo = ()+    type AttrLabel MessageDialogButtonsPropertyInfo = "MessageDialog::buttons"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructMessageDialogButtons++-- VVV Prop "image"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getMessageDialogImage :: (MonadIO m, MessageDialogK o) => o -> m Widget+getMessageDialogImage obj = liftIO $ getObjectPropertyObject obj "image" Widget++setMessageDialogImage :: (MonadIO m, MessageDialogK o, WidgetK a) => o -> a -> m ()+setMessageDialogImage obj val = liftIO $ setObjectPropertyObject obj "image" val++constructMessageDialogImage :: (WidgetK a) => a -> IO ([Char], GValue)+constructMessageDialogImage val = constructObjectPropertyObject "image" val++data MessageDialogImagePropertyInfo+instance AttrInfo MessageDialogImagePropertyInfo where+    type AttrAllowedOps MessageDialogImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogImagePropertyInfo = WidgetK+    type AttrBaseTypeConstraint MessageDialogImagePropertyInfo = MessageDialogK+    type AttrGetType MessageDialogImagePropertyInfo = Widget+    type AttrLabel MessageDialogImagePropertyInfo = "MessageDialog::image"+    attrGet _ = getMessageDialogImage+    attrSet _ = setMessageDialogImage+    attrConstruct _ = constructMessageDialogImage++-- VVV Prop "message-area"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable]++getMessageDialogMessageArea :: (MonadIO m, MessageDialogK o) => o -> m Widget+getMessageDialogMessageArea obj = liftIO $ getObjectPropertyObject obj "message-area" Widget++data MessageDialogMessageAreaPropertyInfo+instance AttrInfo MessageDialogMessageAreaPropertyInfo where+    type AttrAllowedOps MessageDialogMessageAreaPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint MessageDialogMessageAreaPropertyInfo = (~) ()+    type AttrBaseTypeConstraint MessageDialogMessageAreaPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogMessageAreaPropertyInfo = Widget+    type AttrLabel MessageDialogMessageAreaPropertyInfo = "MessageDialog::message-area"+    attrGet _ = getMessageDialogMessageArea+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "message-type"+   -- Type: TInterface "Gtk" "MessageType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getMessageDialogMessageType :: (MonadIO m, MessageDialogK o) => o -> m MessageType+getMessageDialogMessageType obj = liftIO $ getObjectPropertyEnum obj "message-type"++setMessageDialogMessageType :: (MonadIO m, MessageDialogK o) => o -> MessageType -> m ()+setMessageDialogMessageType obj val = liftIO $ setObjectPropertyEnum obj "message-type" val++constructMessageDialogMessageType :: MessageType -> IO ([Char], GValue)+constructMessageDialogMessageType val = constructObjectPropertyEnum "message-type" val++data MessageDialogMessageTypePropertyInfo+instance AttrInfo MessageDialogMessageTypePropertyInfo where+    type AttrAllowedOps MessageDialogMessageTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogMessageTypePropertyInfo = (~) MessageType+    type AttrBaseTypeConstraint MessageDialogMessageTypePropertyInfo = MessageDialogK+    type AttrGetType MessageDialogMessageTypePropertyInfo = MessageType+    type AttrLabel MessageDialogMessageTypePropertyInfo = "MessageDialog::message-type"+    attrGet _ = getMessageDialogMessageType+    attrSet _ = setMessageDialogMessageType+    attrConstruct _ = constructMessageDialogMessageType++-- VVV Prop "secondary-text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMessageDialogSecondaryText :: (MonadIO m, MessageDialogK o) => o -> m T.Text+getMessageDialogSecondaryText obj = liftIO $ getObjectPropertyString obj "secondary-text"++setMessageDialogSecondaryText :: (MonadIO m, MessageDialogK o) => o -> T.Text -> m ()+setMessageDialogSecondaryText obj val = liftIO $ setObjectPropertyString obj "secondary-text" val++constructMessageDialogSecondaryText :: T.Text -> IO ([Char], GValue)+constructMessageDialogSecondaryText val = constructObjectPropertyString "secondary-text" val++data MessageDialogSecondaryTextPropertyInfo+instance AttrInfo MessageDialogSecondaryTextPropertyInfo where+    type AttrAllowedOps MessageDialogSecondaryTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogSecondaryTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MessageDialogSecondaryTextPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogSecondaryTextPropertyInfo = T.Text+    type AttrLabel MessageDialogSecondaryTextPropertyInfo = "MessageDialog::secondary-text"+    attrGet _ = getMessageDialogSecondaryText+    attrSet _ = setMessageDialogSecondaryText+    attrConstruct _ = constructMessageDialogSecondaryText++-- VVV Prop "secondary-use-markup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMessageDialogSecondaryUseMarkup :: (MonadIO m, MessageDialogK o) => o -> m Bool+getMessageDialogSecondaryUseMarkup obj = liftIO $ getObjectPropertyBool obj "secondary-use-markup"++setMessageDialogSecondaryUseMarkup :: (MonadIO m, MessageDialogK o) => o -> Bool -> m ()+setMessageDialogSecondaryUseMarkup obj val = liftIO $ setObjectPropertyBool obj "secondary-use-markup" val++constructMessageDialogSecondaryUseMarkup :: Bool -> IO ([Char], GValue)+constructMessageDialogSecondaryUseMarkup val = constructObjectPropertyBool "secondary-use-markup" val++data MessageDialogSecondaryUseMarkupPropertyInfo+instance AttrInfo MessageDialogSecondaryUseMarkupPropertyInfo where+    type AttrAllowedOps MessageDialogSecondaryUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogSecondaryUseMarkupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MessageDialogSecondaryUseMarkupPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogSecondaryUseMarkupPropertyInfo = Bool+    type AttrLabel MessageDialogSecondaryUseMarkupPropertyInfo = "MessageDialog::secondary-use-markup"+    attrGet _ = getMessageDialogSecondaryUseMarkup+    attrSet _ = setMessageDialogSecondaryUseMarkup+    attrConstruct _ = constructMessageDialogSecondaryUseMarkup++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getMessageDialogText :: (MonadIO m, MessageDialogK o) => o -> m T.Text+getMessageDialogText obj = liftIO $ getObjectPropertyString obj "text"++setMessageDialogText :: (MonadIO m, MessageDialogK o) => o -> T.Text -> m ()+setMessageDialogText obj val = liftIO $ setObjectPropertyString obj "text" val++constructMessageDialogText :: T.Text -> IO ([Char], GValue)+constructMessageDialogText val = constructObjectPropertyString "text" val++data MessageDialogTextPropertyInfo+instance AttrInfo MessageDialogTextPropertyInfo where+    type AttrAllowedOps MessageDialogTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint MessageDialogTextPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogTextPropertyInfo = T.Text+    type AttrLabel MessageDialogTextPropertyInfo = "MessageDialog::text"+    attrGet _ = getMessageDialogText+    attrSet _ = setMessageDialogText+    attrConstruct _ = constructMessageDialogText++-- VVV Prop "use-markup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getMessageDialogUseMarkup :: (MonadIO m, MessageDialogK o) => o -> m Bool+getMessageDialogUseMarkup obj = liftIO $ getObjectPropertyBool obj "use-markup"++setMessageDialogUseMarkup :: (MonadIO m, MessageDialogK o) => o -> Bool -> m ()+setMessageDialogUseMarkup obj val = liftIO $ setObjectPropertyBool obj "use-markup" val++constructMessageDialogUseMarkup :: Bool -> IO ([Char], GValue)+constructMessageDialogUseMarkup val = constructObjectPropertyBool "use-markup" val++data MessageDialogUseMarkupPropertyInfo+instance AttrInfo MessageDialogUseMarkupPropertyInfo where+    type AttrAllowedOps MessageDialogUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MessageDialogUseMarkupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint MessageDialogUseMarkupPropertyInfo = MessageDialogK+    type AttrGetType MessageDialogUseMarkupPropertyInfo = Bool+    type AttrLabel MessageDialogUseMarkupPropertyInfo = "MessageDialog::use-markup"+    attrGet _ = getMessageDialogUseMarkup+    attrSet _ = setMessageDialogUseMarkup+    attrConstruct _ = constructMessageDialogUseMarkup++type instance AttributeList MessageDialog = MessageDialogAttributeList+type MessageDialogAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("buttons", MessageDialogButtonsPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("image", MessageDialogImagePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("message-area", MessageDialogMessageAreaPropertyInfo), '("message-type", MessageDialogMessageTypePropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("secondary-text", MessageDialogSecondaryTextPropertyInfo), '("secondary-use-markup", MessageDialogSecondaryUseMarkupPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("text", MessageDialogTextPropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("use-header-bar", DialogUseHeaderBarPropertyInfo), '("use-markup", MessageDialogUseMarkupPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList MessageDialog = MessageDialogSignalList+type MessageDialogSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("close", DialogCloseSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("response", DialogResponseSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MessageDialog::get_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_message_dialog_get_image" gtk_message_dialog_get_image :: +    Ptr MessageDialog ->                    -- _obj : TInterface "Gtk" "MessageDialog"+    IO (Ptr Widget)++{-# DEPRECATED messageDialogGetImage ["(Since version 3.12)","Use #GtkDialog for dialogs with images"]#-}+messageDialogGetImage ::+    (MonadIO m, MessageDialogK a) =>+    a ->                                    -- _obj+    m Widget+messageDialogGetImage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_message_dialog_get_image _obj'+    checkUnexpectedReturnNULL "gtk_message_dialog_get_image" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MessageDialog::get_message_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_message_dialog_get_message_area" gtk_message_dialog_get_message_area :: +    Ptr MessageDialog ->                    -- _obj : TInterface "Gtk" "MessageDialog"+    IO (Ptr Widget)+++messageDialogGetMessageArea ::+    (MonadIO m, MessageDialogK a) =>+    a ->                                    -- _obj+    m Widget+messageDialogGetMessageArea _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_message_dialog_get_message_area _obj'+    checkUnexpectedReturnNULL "gtk_message_dialog_get_message_area" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method MessageDialog::set_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_message_dialog_set_image" gtk_message_dialog_set_image :: +    Ptr MessageDialog ->                    -- _obj : TInterface "Gtk" "MessageDialog"+    Ptr Widget ->                           -- image : TInterface "Gtk" "Widget"+    IO ()++{-# DEPRECATED messageDialogSetImage ["(Since version 3.12)","Use #GtkDialog to create dialogs with images"]#-}+messageDialogSetImage ::+    (MonadIO m, MessageDialogK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- image+    m ()+messageDialogSetImage _obj image = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let image' = unsafeManagedPtrCastPtr image+    gtk_message_dialog_set_image _obj' image'+    touchManagedPtr _obj+    touchManagedPtr image+    return ()++-- method MessageDialog::set_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MessageDialog", 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}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_message_dialog_set_markup" gtk_message_dialog_set_markup :: +    Ptr MessageDialog ->                    -- _obj : TInterface "Gtk" "MessageDialog"+    CString ->                              -- str : TBasicType TUTF8+    IO ()+++messageDialogSetMarkup ::+    (MonadIO m, MessageDialogK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- str+    m ()+messageDialogSetMarkup _obj str = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    str' <- textToCString str+    gtk_message_dialog_set_markup _obj' str'+    touchManagedPtr _obj+    freeMem str'+    return ()++
+ GI/Gtk/Objects/MessageDialog.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.MessageDialog where++import Prelude ()+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 MessageDialog = MessageDialog (ForeignPtr MessageDialog)+instance GObject MessageDialog where+class GObject o => MessageDialogK o+instance (GObject o, IsDescendantOf MessageDialog o) => MessageDialogK o+data MessageDialogButtonsPropertyInfo+data MessageDialogImagePropertyInfo+data MessageDialogMessageAreaPropertyInfo+data MessageDialogMessageTypePropertyInfo+data MessageDialogSecondaryTextPropertyInfo+data MessageDialogSecondaryUseMarkupPropertyInfo+data MessageDialogTextPropertyInfo+data MessageDialogUseMarkupPropertyInfo
+ GI/Gtk/Objects/Misc.hs view
@@ -0,0 +1,329 @@++{- |+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.Gtk.Objects.Misc+    ( ++-- * Exported types+    Misc(..)                                ,+    MiscK                                   ,+    toMisc                                  ,+    noMisc                                  ,+++ -- * Methods+-- ** miscGetAlignment+    miscGetAlignment                        ,+++-- ** miscGetPadding+    miscGetPadding                          ,+++-- ** miscSetAlignment+    miscSetAlignment                        ,+++-- ** miscSetPadding+    miscSetPadding                          ,+++++ -- * Properties+-- ** Xalign+    MiscXalignPropertyInfo                  ,+    constructMiscXalign                     ,+    getMiscXalign                           ,+    setMiscXalign                           ,+++-- ** Xpad+    MiscXpadPropertyInfo                    ,+    constructMiscXpad                       ,+    getMiscXpad                             ,+    setMiscXpad                             ,+++-- ** Yalign+    MiscYalignPropertyInfo                  ,+    constructMiscYalign                     ,+    getMiscYalign                           ,+    setMiscYalign                           ,+++-- ** Ypad+    MiscYpadPropertyInfo                    ,+    constructMiscYpad                       ,+    getMiscYpad                             ,+    setMiscYpad                             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Misc = Misc (ForeignPtr Misc)+foreign import ccall "gtk_misc_get_type"+    c_gtk_misc_get_type :: IO GType++type instance ParentTypes Misc = MiscParentTypes+type MiscParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Misc where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_misc_get_type+    ++class GObject o => MiscK o+instance (GObject o, IsDescendantOf Misc o) => MiscK o++toMisc :: MiscK o => o -> IO Misc+toMisc = unsafeCastTo Misc++noMisc :: Maybe Misc+noMisc = Nothing++-- VVV Prop "xalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getMiscXalign :: (MonadIO m, MiscK o) => o -> m Float+getMiscXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"++setMiscXalign :: (MonadIO m, MiscK o) => o -> Float -> m ()+setMiscXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val++constructMiscXalign :: Float -> IO ([Char], GValue)+constructMiscXalign val = constructObjectPropertyFloat "xalign" val++data MiscXalignPropertyInfo+instance AttrInfo MiscXalignPropertyInfo where+    type AttrAllowedOps MiscXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MiscXalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint MiscXalignPropertyInfo = MiscK+    type AttrGetType MiscXalignPropertyInfo = Float+    type AttrLabel MiscXalignPropertyInfo = "Misc::xalign"+    attrGet _ = getMiscXalign+    attrSet _ = setMiscXalign+    attrConstruct _ = constructMiscXalign++-- VVV Prop "xpad"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getMiscXpad :: (MonadIO m, MiscK o) => o -> m Int32+getMiscXpad obj = liftIO $ getObjectPropertyCInt obj "xpad"++setMiscXpad :: (MonadIO m, MiscK o) => o -> Int32 -> m ()+setMiscXpad obj val = liftIO $ setObjectPropertyCInt obj "xpad" val++constructMiscXpad :: Int32 -> IO ([Char], GValue)+constructMiscXpad val = constructObjectPropertyCInt "xpad" val++data MiscXpadPropertyInfo+instance AttrInfo MiscXpadPropertyInfo where+    type AttrAllowedOps MiscXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MiscXpadPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint MiscXpadPropertyInfo = MiscK+    type AttrGetType MiscXpadPropertyInfo = Int32+    type AttrLabel MiscXpadPropertyInfo = "Misc::xpad"+    attrGet _ = getMiscXpad+    attrSet _ = setMiscXpad+    attrConstruct _ = constructMiscXpad++-- VVV Prop "yalign"+   -- Type: TBasicType TFloat+   -- Flags: [PropertyReadable,PropertyWritable]++getMiscYalign :: (MonadIO m, MiscK o) => o -> m Float+getMiscYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"++setMiscYalign :: (MonadIO m, MiscK o) => o -> Float -> m ()+setMiscYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val++constructMiscYalign :: Float -> IO ([Char], GValue)+constructMiscYalign val = constructObjectPropertyFloat "yalign" val++data MiscYalignPropertyInfo+instance AttrInfo MiscYalignPropertyInfo where+    type AttrAllowedOps MiscYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MiscYalignPropertyInfo = (~) Float+    type AttrBaseTypeConstraint MiscYalignPropertyInfo = MiscK+    type AttrGetType MiscYalignPropertyInfo = Float+    type AttrLabel MiscYalignPropertyInfo = "Misc::yalign"+    attrGet _ = getMiscYalign+    attrSet _ = setMiscYalign+    attrConstruct _ = constructMiscYalign++-- VVV Prop "ypad"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getMiscYpad :: (MonadIO m, MiscK o) => o -> m Int32+getMiscYpad obj = liftIO $ getObjectPropertyCInt obj "ypad"++setMiscYpad :: (MonadIO m, MiscK o) => o -> Int32 -> m ()+setMiscYpad obj val = liftIO $ setObjectPropertyCInt obj "ypad" val++constructMiscYpad :: Int32 -> IO ([Char], GValue)+constructMiscYpad val = constructObjectPropertyCInt "ypad" val++data MiscYpadPropertyInfo+instance AttrInfo MiscYpadPropertyInfo where+    type AttrAllowedOps MiscYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MiscYpadPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint MiscYpadPropertyInfo = MiscK+    type AttrGetType MiscYpadPropertyInfo = Int32+    type AttrLabel MiscYpadPropertyInfo = "Misc::ypad"+    attrGet _ = getMiscYpad+    attrSet _ = setMiscYpad+    attrConstruct _ = constructMiscYpad++type instance AttributeList Misc = MiscAttributeList+type MiscAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", MiscXalignPropertyInfo), '("xpad", MiscXpadPropertyInfo), '("yalign", MiscYalignPropertyInfo), '("ypad", MiscYpadPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Misc = MiscSignalList+type MiscSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Misc::get_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_misc_get_alignment" gtk_misc_get_alignment :: +    Ptr Misc ->                             -- _obj : TInterface "Gtk" "Misc"+    Ptr CFloat ->                           -- xalign : TBasicType TFloat+    Ptr CFloat ->                           -- yalign : TBasicType TFloat+    IO ()++{-# DEPRECATED miscGetAlignment ["(Since version 3.14)","Use #GtkWidget alignment and margin properties."]#-}+miscGetAlignment ::+    (MonadIO m, MiscK a) =>+    a ->                                    -- _obj+    m (Float,Float)+miscGetAlignment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xalign <- allocMem :: IO (Ptr CFloat)+    yalign <- allocMem :: IO (Ptr CFloat)+    gtk_misc_get_alignment _obj' xalign yalign+    xalign' <- peek xalign+    let xalign'' = realToFrac xalign'+    yalign' <- peek yalign+    let yalign'' = realToFrac yalign'+    touchManagedPtr _obj+    freeMem xalign+    freeMem yalign+    return (xalign'', yalign'')++-- method Misc::get_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_misc_get_padding" gtk_misc_get_padding :: +    Ptr Misc ->                             -- _obj : TInterface "Gtk" "Misc"+    Ptr Int32 ->                            -- xpad : TBasicType TInt32+    Ptr Int32 ->                            -- ypad : TBasicType TInt32+    IO ()++{-# DEPRECATED miscGetPadding ["(Since version 3.14)","Use #GtkWidget alignment and margin properties."]#-}+miscGetPadding ::+    (MonadIO m, MiscK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+miscGetPadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    xpad <- allocMem :: IO (Ptr Int32)+    ypad <- allocMem :: IO (Ptr Int32)+    gtk_misc_get_padding _obj' xpad ypad+    xpad' <- peek xpad+    ypad' <- peek ypad+    touchManagedPtr _obj+    freeMem xpad+    freeMem ypad+    return (xpad', ypad')++-- method Misc::set_alignment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_misc_set_alignment" gtk_misc_set_alignment :: +    Ptr Misc ->                             -- _obj : TInterface "Gtk" "Misc"+    CFloat ->                               -- xalign : TBasicType TFloat+    CFloat ->                               -- yalign : TBasicType TFloat+    IO ()++{-# DEPRECATED miscSetAlignment ["(Since version 3.14)","Use #GtkWidget's alignment (#GtkWidget:halign and #GtkWidget:valign) and margin properties or #GtkLabel's #GtkLabel:xalign and #GtkLabel:yalign properties."]#-}+miscSetAlignment ::+    (MonadIO m, MiscK a) =>+    a ->                                    -- _obj+    Float ->                                -- xalign+    Float ->                                -- yalign+    m ()+miscSetAlignment _obj xalign yalign = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let xalign' = realToFrac xalign+    let yalign' = realToFrac yalign+    gtk_misc_set_alignment _obj' xalign' yalign'+    touchManagedPtr _obj+    return ()++-- method Misc::set_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Misc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "xpad", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ypad", 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 "gtk_misc_set_padding" gtk_misc_set_padding :: +    Ptr Misc ->                             -- _obj : TInterface "Gtk" "Misc"+    Int32 ->                                -- xpad : TBasicType TInt32+    Int32 ->                                -- ypad : TBasicType TInt32+    IO ()++{-# DEPRECATED miscSetPadding ["(Since version 3.14)","Use #GtkWidget alignment and margin properties."]#-}+miscSetPadding ::+    (MonadIO m, MiscK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- xpad+    Int32 ->                                -- ypad+    m ()+miscSetPadding _obj xpad ypad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_misc_set_padding _obj' xpad ypad+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Misc.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.Misc where++import Prelude ()+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 Misc = Misc (ForeignPtr Misc)+instance GObject Misc where+class GObject o => MiscK o+instance (GObject o, IsDescendantOf Misc o) => MiscK o+data MiscXalignPropertyInfo+data MiscXpadPropertyInfo+data MiscYalignPropertyInfo+data MiscYpadPropertyInfo
+ GI/Gtk/Objects/ModelButton.hs view
@@ -0,0 +1,340 @@++{- |+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.Gtk.Objects.ModelButton+    ( ++-- * Exported types+    ModelButton(..)                         ,+    ModelButtonK                            ,+    toModelButton                           ,+    noModelButton                           ,+++ -- * Methods+-- ** modelButtonNew+    modelButtonNew                          ,+++++ -- * Properties+-- ** Active+    ModelButtonActivePropertyInfo           ,+    constructModelButtonActive              ,+    getModelButtonActive                    ,+    setModelButtonActive                    ,+++-- ** Centered+    ModelButtonCenteredPropertyInfo         ,+    constructModelButtonCentered            ,+    getModelButtonCentered                  ,+    setModelButtonCentered                  ,+++-- ** Icon+    ModelButtonIconPropertyInfo             ,+    constructModelButtonIcon                ,+    getModelButtonIcon                      ,+    setModelButtonIcon                      ,+++-- ** Iconic+    ModelButtonIconicPropertyInfo           ,+    constructModelButtonIconic              ,+    getModelButtonIconic                    ,+    setModelButtonIconic                    ,+++-- ** Inverted+    ModelButtonInvertedPropertyInfo         ,+    constructModelButtonInverted            ,+    getModelButtonInverted                  ,+    setModelButtonInverted                  ,+++-- ** MenuName+    ModelButtonMenuNamePropertyInfo         ,+    constructModelButtonMenuName            ,+    getModelButtonMenuName                  ,+    setModelButtonMenuName                  ,+++-- ** Role+    ModelButtonRolePropertyInfo             ,+    constructModelButtonRole                ,+    getModelButtonRole                      ,+    setModelButtonRole                      ,+++-- ** Text+    ModelButtonTextPropertyInfo             ,+    constructModelButtonText                ,+    getModelButtonText                      ,+    setModelButtonText                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype ModelButton = ModelButton (ForeignPtr ModelButton)+foreign import ccall "gtk_model_button_get_type"+    c_gtk_model_button_get_type :: IO GType++type instance ParentTypes ModelButton = ModelButtonParentTypes+type ModelButtonParentTypes = '[Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject ModelButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_model_button_get_type+    ++class GObject o => ModelButtonK o+instance (GObject o, IsDescendantOf ModelButton o) => ModelButtonK o++toModelButton :: ModelButtonK o => o -> IO ModelButton+toModelButton = unsafeCastTo ModelButton++noModelButton :: Maybe ModelButton+noModelButton = Nothing++-- VVV Prop "active"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonActive :: (MonadIO m, ModelButtonK o) => o -> m Bool+getModelButtonActive obj = liftIO $ getObjectPropertyBool obj "active"++setModelButtonActive :: (MonadIO m, ModelButtonK o) => o -> Bool -> m ()+setModelButtonActive obj val = liftIO $ setObjectPropertyBool obj "active" val++constructModelButtonActive :: Bool -> IO ([Char], GValue)+constructModelButtonActive val = constructObjectPropertyBool "active" val++data ModelButtonActivePropertyInfo+instance AttrInfo ModelButtonActivePropertyInfo where+    type AttrAllowedOps ModelButtonActivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonActivePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ModelButtonActivePropertyInfo = ModelButtonK+    type AttrGetType ModelButtonActivePropertyInfo = Bool+    type AttrLabel ModelButtonActivePropertyInfo = "ModelButton::active"+    attrGet _ = getModelButtonActive+    attrSet _ = setModelButtonActive+    attrConstruct _ = constructModelButtonActive++-- VVV Prop "centered"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonCentered :: (MonadIO m, ModelButtonK o) => o -> m Bool+getModelButtonCentered obj = liftIO $ getObjectPropertyBool obj "centered"++setModelButtonCentered :: (MonadIO m, ModelButtonK o) => o -> Bool -> m ()+setModelButtonCentered obj val = liftIO $ setObjectPropertyBool obj "centered" val++constructModelButtonCentered :: Bool -> IO ([Char], GValue)+constructModelButtonCentered val = constructObjectPropertyBool "centered" val++data ModelButtonCenteredPropertyInfo+instance AttrInfo ModelButtonCenteredPropertyInfo where+    type AttrAllowedOps ModelButtonCenteredPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonCenteredPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ModelButtonCenteredPropertyInfo = ModelButtonK+    type AttrGetType ModelButtonCenteredPropertyInfo = Bool+    type AttrLabel ModelButtonCenteredPropertyInfo = "ModelButton::centered"+    attrGet _ = getModelButtonCentered+    attrSet _ = setModelButtonCentered+    attrConstruct _ = constructModelButtonCentered++-- VVV Prop "icon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonIcon :: (MonadIO m, ModelButtonK o) => o -> m Gio.Icon+getModelButtonIcon obj = liftIO $ getObjectPropertyObject obj "icon" Gio.Icon++setModelButtonIcon :: (MonadIO m, ModelButtonK o, Gio.IconK a) => o -> a -> m ()+setModelButtonIcon obj val = liftIO $ setObjectPropertyObject obj "icon" val++constructModelButtonIcon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructModelButtonIcon val = constructObjectPropertyObject "icon" val++data ModelButtonIconPropertyInfo+instance AttrInfo ModelButtonIconPropertyInfo where+    type AttrAllowedOps ModelButtonIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonIconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint ModelButtonIconPropertyInfo = ModelButtonK+    type AttrGetType ModelButtonIconPropertyInfo = Gio.Icon+    type AttrLabel ModelButtonIconPropertyInfo = "ModelButton::icon"+    attrGet _ = getModelButtonIcon+    attrSet _ = setModelButtonIcon+    attrConstruct _ = constructModelButtonIcon++-- VVV Prop "iconic"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonIconic :: (MonadIO m, ModelButtonK o) => o -> m Bool+getModelButtonIconic obj = liftIO $ getObjectPropertyBool obj "iconic"++setModelButtonIconic :: (MonadIO m, ModelButtonK o) => o -> Bool -> m ()+setModelButtonIconic obj val = liftIO $ setObjectPropertyBool obj "iconic" val++constructModelButtonIconic :: Bool -> IO ([Char], GValue)+constructModelButtonIconic val = constructObjectPropertyBool "iconic" val++data ModelButtonIconicPropertyInfo+instance AttrInfo ModelButtonIconicPropertyInfo where+    type AttrAllowedOps ModelButtonIconicPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonIconicPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ModelButtonIconicPropertyInfo = ModelButtonK+    type AttrGetType ModelButtonIconicPropertyInfo = Bool+    type AttrLabel ModelButtonIconicPropertyInfo = "ModelButton::iconic"+    attrGet _ = getModelButtonIconic+    attrSet _ = setModelButtonIconic+    attrConstruct _ = constructModelButtonIconic++-- VVV Prop "inverted"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonInverted :: (MonadIO m, ModelButtonK o) => o -> m Bool+getModelButtonInverted obj = liftIO $ getObjectPropertyBool obj "inverted"++setModelButtonInverted :: (MonadIO m, ModelButtonK o) => o -> Bool -> m ()+setModelButtonInverted obj val = liftIO $ setObjectPropertyBool obj "inverted" val++constructModelButtonInverted :: Bool -> IO ([Char], GValue)+constructModelButtonInverted val = constructObjectPropertyBool "inverted" val++data ModelButtonInvertedPropertyInfo+instance AttrInfo ModelButtonInvertedPropertyInfo where+    type AttrAllowedOps ModelButtonInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonInvertedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ModelButtonInvertedPropertyInfo = ModelButtonK+    type AttrGetType ModelButtonInvertedPropertyInfo = Bool+    type AttrLabel ModelButtonInvertedPropertyInfo = "ModelButton::inverted"+    attrGet _ = getModelButtonInverted+    attrSet _ = setModelButtonInverted+    attrConstruct _ = constructModelButtonInverted++-- VVV Prop "menu-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonMenuName :: (MonadIO m, ModelButtonK o) => o -> m T.Text+getModelButtonMenuName obj = liftIO $ getObjectPropertyString obj "menu-name"++setModelButtonMenuName :: (MonadIO m, ModelButtonK o) => o -> T.Text -> m ()+setModelButtonMenuName obj val = liftIO $ setObjectPropertyString obj "menu-name" val++constructModelButtonMenuName :: T.Text -> IO ([Char], GValue)+constructModelButtonMenuName val = constructObjectPropertyString "menu-name" val++data ModelButtonMenuNamePropertyInfo+instance AttrInfo ModelButtonMenuNamePropertyInfo where+    type AttrAllowedOps ModelButtonMenuNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonMenuNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ModelButtonMenuNamePropertyInfo = ModelButtonK+    type AttrGetType ModelButtonMenuNamePropertyInfo = T.Text+    type AttrLabel ModelButtonMenuNamePropertyInfo = "ModelButton::menu-name"+    attrGet _ = getModelButtonMenuName+    attrSet _ = setModelButtonMenuName+    attrConstruct _ = constructModelButtonMenuName++-- VVV Prop "role"+   -- Type: TInterface "Gtk" "ButtonRole"+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonRole :: (MonadIO m, ModelButtonK o) => o -> m ButtonRole+getModelButtonRole obj = liftIO $ getObjectPropertyEnum obj "role"++setModelButtonRole :: (MonadIO m, ModelButtonK o) => o -> ButtonRole -> m ()+setModelButtonRole obj val = liftIO $ setObjectPropertyEnum obj "role" val++constructModelButtonRole :: ButtonRole -> IO ([Char], GValue)+constructModelButtonRole val = constructObjectPropertyEnum "role" val++data ModelButtonRolePropertyInfo+instance AttrInfo ModelButtonRolePropertyInfo where+    type AttrAllowedOps ModelButtonRolePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonRolePropertyInfo = (~) ButtonRole+    type AttrBaseTypeConstraint ModelButtonRolePropertyInfo = ModelButtonK+    type AttrGetType ModelButtonRolePropertyInfo = ButtonRole+    type AttrLabel ModelButtonRolePropertyInfo = "ModelButton::role"+    attrGet _ = getModelButtonRole+    attrSet _ = setModelButtonRole+    attrConstruct _ = constructModelButtonRole++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getModelButtonText :: (MonadIO m, ModelButtonK o) => o -> m T.Text+getModelButtonText obj = liftIO $ getObjectPropertyString obj "text"++setModelButtonText :: (MonadIO m, ModelButtonK o) => o -> T.Text -> m ()+setModelButtonText obj val = liftIO $ setObjectPropertyString obj "text" val++constructModelButtonText :: T.Text -> IO ([Char], GValue)+constructModelButtonText val = constructObjectPropertyString "text" val++data ModelButtonTextPropertyInfo+instance AttrInfo ModelButtonTextPropertyInfo where+    type AttrAllowedOps ModelButtonTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ModelButtonTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ModelButtonTextPropertyInfo = ModelButtonK+    type AttrGetType ModelButtonTextPropertyInfo = T.Text+    type AttrLabel ModelButtonTextPropertyInfo = "ModelButton::text"+    attrGet _ = getModelButtonText+    attrSet _ = setModelButtonText+    attrConstruct _ = constructModelButtonText++type instance AttributeList ModelButton = ModelButtonAttributeList+type ModelButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", ModelButtonActivePropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("centered", ModelButtonCenteredPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("icon", ModelButtonIconPropertyInfo), '("iconic", ModelButtonIconicPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("inverted", ModelButtonInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("menu-name", ModelButtonMenuNamePropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", ModelButtonRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("text", ModelButtonTextPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ModelButton = ModelButtonSignalList+type ModelButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ModelButton::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ModelButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_model_button_new" gtk_model_button_new :: +    IO (Ptr ModelButton)+++modelButtonNew ::+    (MonadIO m) =>+    m ModelButton+modelButtonNew  = liftIO $ do+    result <- gtk_model_button_new+    checkUnexpectedReturnNULL "gtk_model_button_new" result+    result' <- (newObject ModelButton) result+    return result'++
+ GI/Gtk/Objects/ModelButton.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gtk.Objects.ModelButton where++import Prelude ()+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 ModelButton = ModelButton (ForeignPtr ModelButton)+instance GObject ModelButton where+class GObject o => ModelButtonK o+instance (GObject o, IsDescendantOf ModelButton o) => ModelButtonK o+data ModelButtonActivePropertyInfo+data ModelButtonCenteredPropertyInfo+data ModelButtonIconPropertyInfo+data ModelButtonIconicPropertyInfo+data ModelButtonInvertedPropertyInfo+data ModelButtonMenuNamePropertyInfo+data ModelButtonRolePropertyInfo+data ModelButtonTextPropertyInfo
+ GI/Gtk/Objects/MountOperation.hs view
@@ -0,0 +1,342 @@++{- |+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.Gtk.Objects.MountOperation+    ( ++-- * Exported types+    MountOperation(..)                      ,+    MountOperationK                         ,+    toMountOperation                        ,+    noMountOperation                        ,+++ -- * Methods+-- ** mountOperationGetParent+    mountOperationGetParent                 ,+++-- ** mountOperationGetScreen+    mountOperationGetScreen                 ,+++-- ** mountOperationIsShowing+    mountOperationIsShowing                 ,+++-- ** mountOperationNew+    mountOperationNew                       ,+++-- ** mountOperationSetParent+    mountOperationSetParent                 ,+++-- ** mountOperationSetScreen+    mountOperationSetScreen                 ,+++++ -- * Properties+-- ** IsShowing+    MountOperationIsShowingPropertyInfo     ,+    getMountOperationIsShowing              ,+++-- ** Parent+    MountOperationParentPropertyInfo        ,+    constructMountOperationParent           ,+    getMountOperationParent                 ,+    setMountOperationParent                 ,+++-- ** Screen+    MountOperationScreenPropertyInfo        ,+    constructMountOperationScreen           ,+    getMountOperationScreen                 ,+    setMountOperationScreen                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Gio as Gio++newtype MountOperation = MountOperation (ForeignPtr MountOperation)+foreign import ccall "gtk_mount_operation_get_type"+    c_gtk_mount_operation_get_type :: IO GType++type instance ParentTypes MountOperation = MountOperationParentTypes+type MountOperationParentTypes = '[Gio.MountOperation, GObject.Object]++instance GObject MountOperation where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_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++-- VVV Prop "is-showing"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getMountOperationIsShowing :: (MonadIO m, MountOperationK o) => o -> m Bool+getMountOperationIsShowing obj = liftIO $ getObjectPropertyBool obj "is-showing"++data MountOperationIsShowingPropertyInfo+instance AttrInfo MountOperationIsShowingPropertyInfo where+    type AttrAllowedOps MountOperationIsShowingPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint MountOperationIsShowingPropertyInfo = (~) ()+    type AttrBaseTypeConstraint MountOperationIsShowingPropertyInfo = MountOperationK+    type AttrGetType MountOperationIsShowingPropertyInfo = Bool+    type AttrLabel MountOperationIsShowingPropertyInfo = "MountOperation::is-showing"+    attrGet _ = getMountOperationIsShowing+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "parent"+   -- Type: TInterface "Gtk" "Window"+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationParent :: (MonadIO m, MountOperationK o) => o -> m Window+getMountOperationParent obj = liftIO $ getObjectPropertyObject obj "parent" Window++setMountOperationParent :: (MonadIO m, MountOperationK o, WindowK a) => o -> a -> m ()+setMountOperationParent obj val = liftIO $ setObjectPropertyObject obj "parent" val++constructMountOperationParent :: (WindowK a) => a -> IO ([Char], GValue)+constructMountOperationParent val = constructObjectPropertyObject "parent" val++data MountOperationParentPropertyInfo+instance AttrInfo MountOperationParentPropertyInfo where+    type AttrAllowedOps MountOperationParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationParentPropertyInfo = WindowK+    type AttrBaseTypeConstraint MountOperationParentPropertyInfo = MountOperationK+    type AttrGetType MountOperationParentPropertyInfo = Window+    type AttrLabel MountOperationParentPropertyInfo = "MountOperation::parent"+    attrGet _ = getMountOperationParent+    attrSet _ = setMountOperationParent+    attrConstruct _ = constructMountOperationParent++-- VVV Prop "screen"+   -- Type: TInterface "Gdk" "Screen"+   -- Flags: [PropertyReadable,PropertyWritable]++getMountOperationScreen :: (MonadIO m, MountOperationK o) => o -> m Gdk.Screen+getMountOperationScreen obj = liftIO $ getObjectPropertyObject obj "screen" Gdk.Screen++setMountOperationScreen :: (MonadIO m, MountOperationK o, Gdk.ScreenK a) => o -> a -> m ()+setMountOperationScreen obj val = liftIO $ setObjectPropertyObject obj "screen" val++constructMountOperationScreen :: (Gdk.ScreenK a) => a -> IO ([Char], GValue)+constructMountOperationScreen val = constructObjectPropertyObject "screen" val++data MountOperationScreenPropertyInfo+instance AttrInfo MountOperationScreenPropertyInfo where+    type AttrAllowedOps MountOperationScreenPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint MountOperationScreenPropertyInfo = Gdk.ScreenK+    type AttrBaseTypeConstraint MountOperationScreenPropertyInfo = MountOperationK+    type AttrGetType MountOperationScreenPropertyInfo = Gdk.Screen+    type AttrLabel MountOperationScreenPropertyInfo = "MountOperation::screen"+    attrGet _ = getMountOperationScreen+    attrSet _ = setMountOperationScreen+    attrConstruct _ = constructMountOperationScreen++type instance AttributeList MountOperation = MountOperationAttributeList+type MountOperationAttributeList = ('[ '("anonymous", Gio.MountOperationAnonymousPropertyInfo), '("choice", Gio.MountOperationChoicePropertyInfo), '("domain", Gio.MountOperationDomainPropertyInfo), '("is-showing", MountOperationIsShowingPropertyInfo), '("parent", MountOperationParentPropertyInfo), '("password", Gio.MountOperationPasswordPropertyInfo), '("password-save", Gio.MountOperationPasswordSavePropertyInfo), '("screen", MountOperationScreenPropertyInfo), '("username", Gio.MountOperationUsernamePropertyInfo)] :: [(Symbol, *)])++type instance SignalList MountOperation = MountOperationSignalList+type MountOperationSignalList = ('[ '("aborted", Gio.MountOperationAbortedSignalInfo), '("ask-password", Gio.MountOperationAskPasswordSignalInfo), '("ask-question", Gio.MountOperationAskQuestionSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("reply", Gio.MountOperationReplySignalInfo), '("show-processes", Gio.MountOperationShowProcessesSignalInfo), '("show-unmount-progress", Gio.MountOperationShowUnmountProgressSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method MountOperation::new+-- method type : Constructor+-- Args : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "MountOperation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_new" gtk_mount_operation_new :: +    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    IO (Ptr MountOperation)+++mountOperationNew ::+    (MonadIO m, WindowK a) =>+    Maybe (a) ->                            -- parent+    m MountOperation+mountOperationNew parent = liftIO $ do+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- gtk_mount_operation_new maybeParent+    checkUnexpectedReturnNULL "gtk_mount_operation_new" result+    result' <- (wrapObject MountOperation) result+    whenJust parent touchManagedPtr+    return result'++-- method MountOperation::get_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_get_parent" gtk_mount_operation_get_parent :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gtk" "MountOperation"+    IO (Ptr Window)+++mountOperationGetParent ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m Window+mountOperationGetParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_mount_operation_get_parent _obj'+    checkUnexpectedReturnNULL "gtk_mount_operation_get_parent" result+    result' <- (newObject Window) result+    touchManagedPtr _obj+    return result'++-- method MountOperation::get_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Screen"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_get_screen" gtk_mount_operation_get_screen :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gtk" "MountOperation"+    IO (Ptr Gdk.Screen)+++mountOperationGetScreen ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m Gdk.Screen+mountOperationGetScreen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_mount_operation_get_screen _obj'+    checkUnexpectedReturnNULL "gtk_mount_operation_get_screen" result+    result' <- (newObject Gdk.Screen) result+    touchManagedPtr _obj+    return result'++-- method MountOperation::is_showing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_is_showing" gtk_mount_operation_is_showing :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gtk" "MountOperation"+    IO CInt+++mountOperationIsShowing ::+    (MonadIO m, MountOperationK a) =>+    a ->                                    -- _obj+    m Bool+mountOperationIsShowing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_mount_operation_is_showing _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method MountOperation::set_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_set_parent" gtk_mount_operation_set_parent :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gtk" "MountOperation"+    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    IO ()+++mountOperationSetParent ::+    (MonadIO m, MountOperationK a, WindowK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- parent+    m ()+mountOperationSetParent _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    gtk_mount_operation_set_parent _obj' maybeParent+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    return ()++-- method MountOperation::set_screen+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "MountOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "screen", argType = TInterface "Gdk" "Screen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_mount_operation_set_screen" gtk_mount_operation_set_screen :: +    Ptr MountOperation ->                   -- _obj : TInterface "Gtk" "MountOperation"+    Ptr Gdk.Screen ->                       -- screen : TInterface "Gdk" "Screen"+    IO ()+++mountOperationSetScreen ::+    (MonadIO m, MountOperationK a, Gdk.ScreenK b) =>+    a ->                                    -- _obj+    b ->                                    -- screen+    m ()+mountOperationSetScreen _obj screen = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let screen' = unsafeManagedPtrCastPtr screen+    gtk_mount_operation_set_screen _obj' screen'+    touchManagedPtr _obj+    touchManagedPtr screen+    return ()++
+ GI/Gtk/Objects/MountOperation.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.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 MountOperationIsShowingPropertyInfo+data MountOperationParentPropertyInfo+data MountOperationScreenPropertyInfo
+ GI/Gtk/Objects/Notebook.hs view
@@ -0,0 +1,2412 @@++{- |+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.Gtk.Objects.Notebook+    ( ++-- * Exported types+    Notebook(..)                            ,+    NotebookK                               ,+    toNotebook                              ,+    noNotebook                              ,+++ -- * Methods+-- ** notebookAppendPage+    notebookAppendPage                      ,+++-- ** notebookAppendPageMenu+    notebookAppendPageMenu                  ,+++-- ** notebookDetachTab+    notebookDetachTab                       ,+++-- ** notebookGetActionWidget+    notebookGetActionWidget                 ,+++-- ** notebookGetCurrentPage+    notebookGetCurrentPage                  ,+++-- ** notebookGetGroupName+    notebookGetGroupName                    ,+++-- ** notebookGetMenuLabel+    notebookGetMenuLabel                    ,+++-- ** notebookGetMenuLabelText+    notebookGetMenuLabelText                ,+++-- ** notebookGetNPages+    notebookGetNPages                       ,+++-- ** notebookGetNthPage+    notebookGetNthPage                      ,+++-- ** notebookGetScrollable+    notebookGetScrollable                   ,+++-- ** notebookGetShowBorder+    notebookGetShowBorder                   ,+++-- ** notebookGetShowTabs+    notebookGetShowTabs                     ,+++-- ** notebookGetTabDetachable+    notebookGetTabDetachable                ,+++-- ** notebookGetTabHborder+    notebookGetTabHborder                   ,+++-- ** notebookGetTabLabel+    notebookGetTabLabel                     ,+++-- ** notebookGetTabLabelText+    notebookGetTabLabelText                 ,+++-- ** notebookGetTabPos+    notebookGetTabPos                       ,+++-- ** notebookGetTabReorderable+    notebookGetTabReorderable               ,+++-- ** notebookGetTabVborder+    notebookGetTabVborder                   ,+++-- ** notebookInsertPage+    notebookInsertPage                      ,+++-- ** notebookInsertPageMenu+    notebookInsertPageMenu                  ,+++-- ** notebookNew+    notebookNew                             ,+++-- ** notebookNextPage+    notebookNextPage                        ,+++-- ** notebookPageNum+    notebookPageNum                         ,+++-- ** notebookPopupDisable+    notebookPopupDisable                    ,+++-- ** notebookPopupEnable+    notebookPopupEnable                     ,+++-- ** notebookPrependPage+    notebookPrependPage                     ,+++-- ** notebookPrependPageMenu+    notebookPrependPageMenu                 ,+++-- ** notebookPrevPage+    notebookPrevPage                        ,+++-- ** notebookRemovePage+    notebookRemovePage                      ,+++-- ** notebookReorderChild+    notebookReorderChild                    ,+++-- ** notebookSetActionWidget+    notebookSetActionWidget                 ,+++-- ** notebookSetCurrentPage+    notebookSetCurrentPage                  ,+++-- ** notebookSetGroupName+    notebookSetGroupName                    ,+++-- ** notebookSetMenuLabel+    notebookSetMenuLabel                    ,+++-- ** notebookSetMenuLabelText+    notebookSetMenuLabelText                ,+++-- ** notebookSetScrollable+    notebookSetScrollable                   ,+++-- ** notebookSetShowBorder+    notebookSetShowBorder                   ,+++-- ** notebookSetShowTabs+    notebookSetShowTabs                     ,+++-- ** notebookSetTabDetachable+    notebookSetTabDetachable                ,+++-- ** notebookSetTabLabel+    notebookSetTabLabel                     ,+++-- ** notebookSetTabLabelText+    notebookSetTabLabelText                 ,+++-- ** notebookSetTabPos+    notebookSetTabPos                       ,+++-- ** notebookSetTabReorderable+    notebookSetTabReorderable               ,+++++ -- * Properties+-- ** EnablePopup+    NotebookEnablePopupPropertyInfo         ,+    constructNotebookEnablePopup            ,+    getNotebookEnablePopup                  ,+    setNotebookEnablePopup                  ,+++-- ** GroupName+    NotebookGroupNamePropertyInfo           ,+    constructNotebookGroupName              ,+    getNotebookGroupName                    ,+    setNotebookGroupName                    ,+++-- ** Page+    NotebookPagePropertyInfo                ,+    constructNotebookPage                   ,+    getNotebookPage                         ,+    setNotebookPage                         ,+++-- ** Scrollable+    NotebookScrollablePropertyInfo          ,+    constructNotebookScrollable             ,+    getNotebookScrollable                   ,+    setNotebookScrollable                   ,+++-- ** ShowBorder+    NotebookShowBorderPropertyInfo          ,+    constructNotebookShowBorder             ,+    getNotebookShowBorder                   ,+    setNotebookShowBorder                   ,+++-- ** ShowTabs+    NotebookShowTabsPropertyInfo            ,+    constructNotebookShowTabs               ,+    getNotebookShowTabs                     ,+    setNotebookShowTabs                     ,+++-- ** TabPos+    NotebookTabPosPropertyInfo              ,+    constructNotebookTabPos                 ,+    getNotebookTabPos                       ,+    setNotebookTabPos                       ,+++++ -- * Signals+-- ** ChangeCurrentPage+    NotebookChangeCurrentPageCallback       ,+    NotebookChangeCurrentPageCallbackC      ,+    NotebookChangeCurrentPageSignalInfo     ,+    afterNotebookChangeCurrentPage          ,+    mkNotebookChangeCurrentPageCallback     ,+    noNotebookChangeCurrentPageCallback     ,+    notebookChangeCurrentPageCallbackWrapper,+    notebookChangeCurrentPageClosure        ,+    onNotebookChangeCurrentPage             ,+++-- ** CreateWindow+    NotebookCreateWindowCallback            ,+    NotebookCreateWindowCallbackC           ,+    NotebookCreateWindowSignalInfo          ,+    afterNotebookCreateWindow               ,+    mkNotebookCreateWindowCallback          ,+    noNotebookCreateWindowCallback          ,+    notebookCreateWindowCallbackWrapper     ,+    notebookCreateWindowClosure             ,+    onNotebookCreateWindow                  ,+++-- ** FocusTab+    NotebookFocusTabCallback                ,+    NotebookFocusTabCallbackC               ,+    NotebookFocusTabSignalInfo              ,+    afterNotebookFocusTab                   ,+    mkNotebookFocusTabCallback              ,+    noNotebookFocusTabCallback              ,+    notebookFocusTabCallbackWrapper         ,+    notebookFocusTabClosure                 ,+    onNotebookFocusTab                      ,+++-- ** MoveFocusOut+    NotebookMoveFocusOutCallback            ,+    NotebookMoveFocusOutCallbackC           ,+    NotebookMoveFocusOutSignalInfo          ,+    afterNotebookMoveFocusOut               ,+    mkNotebookMoveFocusOutCallback          ,+    noNotebookMoveFocusOutCallback          ,+    notebookMoveFocusOutCallbackWrapper     ,+    notebookMoveFocusOutClosure             ,+    onNotebookMoveFocusOut                  ,+++-- ** PageAdded+    NotebookPageAddedCallback               ,+    NotebookPageAddedCallbackC              ,+    NotebookPageAddedSignalInfo             ,+    afterNotebookPageAdded                  ,+    mkNotebookPageAddedCallback             ,+    noNotebookPageAddedCallback             ,+    notebookPageAddedCallbackWrapper        ,+    notebookPageAddedClosure                ,+    onNotebookPageAdded                     ,+++-- ** PageRemoved+    NotebookPageRemovedCallback             ,+    NotebookPageRemovedCallbackC            ,+    NotebookPageRemovedSignalInfo           ,+    afterNotebookPageRemoved                ,+    mkNotebookPageRemovedCallback           ,+    noNotebookPageRemovedCallback           ,+    notebookPageRemovedCallbackWrapper      ,+    notebookPageRemovedClosure              ,+    onNotebookPageRemoved                   ,+++-- ** PageReordered+    NotebookPageReorderedCallback           ,+    NotebookPageReorderedCallbackC          ,+    NotebookPageReorderedSignalInfo         ,+    afterNotebookPageReordered              ,+    mkNotebookPageReorderedCallback         ,+    noNotebookPageReorderedCallback         ,+    notebookPageReorderedCallbackWrapper    ,+    notebookPageReorderedClosure            ,+    onNotebookPageReordered                 ,+++-- ** ReorderTab+    NotebookReorderTabCallback              ,+    NotebookReorderTabCallbackC             ,+    NotebookReorderTabSignalInfo            ,+    afterNotebookReorderTab                 ,+    mkNotebookReorderTabCallback            ,+    noNotebookReorderTabCallback            ,+    notebookReorderTabCallbackWrapper       ,+    notebookReorderTabClosure               ,+    onNotebookReorderTab                    ,+++-- ** SelectPage+    NotebookSelectPageCallback              ,+    NotebookSelectPageCallbackC             ,+    NotebookSelectPageSignalInfo            ,+    afterNotebookSelectPage                 ,+    mkNotebookSelectPageCallback            ,+    noNotebookSelectPageCallback            ,+    notebookSelectPageCallbackWrapper       ,+    notebookSelectPageClosure               ,+    onNotebookSelectPage                    ,+++-- ** SwitchPage+    NotebookSwitchPageCallback              ,+    NotebookSwitchPageCallbackC             ,+    NotebookSwitchPageSignalInfo            ,+    afterNotebookSwitchPage                 ,+    mkNotebookSwitchPageCallback            ,+    noNotebookSwitchPageCallback            ,+    notebookSwitchPageCallbackWrapper       ,+    notebookSwitchPageClosure               ,+    onNotebookSwitchPage                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Notebook = Notebook (ForeignPtr Notebook)+foreign import ccall "gtk_notebook_get_type"+    c_gtk_notebook_get_type :: IO GType++type instance ParentTypes Notebook = NotebookParentTypes+type NotebookParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Notebook where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_notebook_get_type+    ++class GObject o => NotebookK o+instance (GObject o, IsDescendantOf Notebook o) => NotebookK o++toNotebook :: NotebookK o => o -> IO Notebook+toNotebook = unsafeCastTo Notebook++noNotebook :: Maybe Notebook+noNotebook = Nothing++-- signal Notebook::change-current-page+type NotebookChangeCurrentPageCallback =+    Int32 ->+    IO Bool++noNotebookChangeCurrentPageCallback :: Maybe NotebookChangeCurrentPageCallback+noNotebookChangeCurrentPageCallback = Nothing++type NotebookChangeCurrentPageCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkNotebookChangeCurrentPageCallback :: NotebookChangeCurrentPageCallbackC -> IO (FunPtr NotebookChangeCurrentPageCallbackC)++notebookChangeCurrentPageClosure :: NotebookChangeCurrentPageCallback -> IO Closure+notebookChangeCurrentPageClosure cb = newCClosure =<< mkNotebookChangeCurrentPageCallback wrapped+    where wrapped = notebookChangeCurrentPageCallbackWrapper cb++notebookChangeCurrentPageCallbackWrapper ::+    NotebookChangeCurrentPageCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO CInt+notebookChangeCurrentPageCallbackWrapper _cb _ object _ = do+    result <- _cb  object+    let result' = (fromIntegral . fromEnum) result+    return result'++onNotebookChangeCurrentPage :: (GObject a, MonadIO m) => a -> NotebookChangeCurrentPageCallback -> m SignalHandlerId+onNotebookChangeCurrentPage obj cb = liftIO $ connectNotebookChangeCurrentPage obj cb SignalConnectBefore+afterNotebookChangeCurrentPage :: (GObject a, MonadIO m) => a -> NotebookChangeCurrentPageCallback -> m SignalHandlerId+afterNotebookChangeCurrentPage obj cb = connectNotebookChangeCurrentPage obj cb SignalConnectAfter++connectNotebookChangeCurrentPage :: (GObject a, MonadIO m) =>+                                    a -> NotebookChangeCurrentPageCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookChangeCurrentPage obj cb after = liftIO $ do+    cb' <- mkNotebookChangeCurrentPageCallback (notebookChangeCurrentPageCallbackWrapper cb)+    connectSignalFunPtr obj "change-current-page" cb' after++-- signal Notebook::create-window+type NotebookCreateWindowCallback =+    Widget ->+    Int32 ->+    Int32 ->+    IO Notebook++noNotebookCreateWindowCallback :: Maybe NotebookCreateWindowCallback+noNotebookCreateWindowCallback = Nothing++type NotebookCreateWindowCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO (Ptr Notebook)++foreign import ccall "wrapper"+    mkNotebookCreateWindowCallback :: NotebookCreateWindowCallbackC -> IO (FunPtr NotebookCreateWindowCallbackC)++notebookCreateWindowClosure :: NotebookCreateWindowCallback -> IO Closure+notebookCreateWindowClosure cb = newCClosure =<< mkNotebookCreateWindowCallback wrapped+    where wrapped = notebookCreateWindowCallbackWrapper cb++notebookCreateWindowCallbackWrapper ::+    NotebookCreateWindowCallback ->+    Ptr () ->+    Ptr Widget ->+    Int32 ->+    Int32 ->+    Ptr () ->+    IO (Ptr Notebook)+notebookCreateWindowCallbackWrapper _cb _ page x y _ = do+    page' <- (newObject Widget) page+    result <- _cb  page' x y+    let result' = unsafeManagedPtrCastPtr result+    return result'++onNotebookCreateWindow :: (GObject a, MonadIO m) => a -> NotebookCreateWindowCallback -> m SignalHandlerId+onNotebookCreateWindow obj cb = liftIO $ connectNotebookCreateWindow obj cb SignalConnectBefore+afterNotebookCreateWindow :: (GObject a, MonadIO m) => a -> NotebookCreateWindowCallback -> m SignalHandlerId+afterNotebookCreateWindow obj cb = connectNotebookCreateWindow obj cb SignalConnectAfter++connectNotebookCreateWindow :: (GObject a, MonadIO m) =>+                               a -> NotebookCreateWindowCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookCreateWindow obj cb after = liftIO $ do+    cb' <- mkNotebookCreateWindowCallback (notebookCreateWindowCallbackWrapper cb)+    connectSignalFunPtr obj "create-window" cb' after++-- signal Notebook::focus-tab+type NotebookFocusTabCallback =+    NotebookTab ->+    IO Bool++noNotebookFocusTabCallback :: Maybe NotebookFocusTabCallback+noNotebookFocusTabCallback = Nothing++type NotebookFocusTabCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkNotebookFocusTabCallback :: NotebookFocusTabCallbackC -> IO (FunPtr NotebookFocusTabCallbackC)++notebookFocusTabClosure :: NotebookFocusTabCallback -> IO Closure+notebookFocusTabClosure cb = newCClosure =<< mkNotebookFocusTabCallback wrapped+    where wrapped = notebookFocusTabCallbackWrapper cb++notebookFocusTabCallbackWrapper ::+    NotebookFocusTabCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO CInt+notebookFocusTabCallbackWrapper _cb _ object _ = do+    let object' = (toEnum . fromIntegral) object+    result <- _cb  object'+    let result' = (fromIntegral . fromEnum) result+    return result'++onNotebookFocusTab :: (GObject a, MonadIO m) => a -> NotebookFocusTabCallback -> m SignalHandlerId+onNotebookFocusTab obj cb = liftIO $ connectNotebookFocusTab obj cb SignalConnectBefore+afterNotebookFocusTab :: (GObject a, MonadIO m) => a -> NotebookFocusTabCallback -> m SignalHandlerId+afterNotebookFocusTab obj cb = connectNotebookFocusTab obj cb SignalConnectAfter++connectNotebookFocusTab :: (GObject a, MonadIO m) =>+                           a -> NotebookFocusTabCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookFocusTab obj cb after = liftIO $ do+    cb' <- mkNotebookFocusTabCallback (notebookFocusTabCallbackWrapper cb)+    connectSignalFunPtr obj "focus-tab" cb' after++-- signal Notebook::move-focus-out+type NotebookMoveFocusOutCallback =+    DirectionType ->+    IO ()++noNotebookMoveFocusOutCallback :: Maybe NotebookMoveFocusOutCallback+noNotebookMoveFocusOutCallback = Nothing++type NotebookMoveFocusOutCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNotebookMoveFocusOutCallback :: NotebookMoveFocusOutCallbackC -> IO (FunPtr NotebookMoveFocusOutCallbackC)++notebookMoveFocusOutClosure :: NotebookMoveFocusOutCallback -> IO Closure+notebookMoveFocusOutClosure cb = newCClosure =<< mkNotebookMoveFocusOutCallback wrapped+    where wrapped = notebookMoveFocusOutCallbackWrapper cb++notebookMoveFocusOutCallbackWrapper ::+    NotebookMoveFocusOutCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+notebookMoveFocusOutCallbackWrapper _cb _ object _ = do+    let object' = (toEnum . fromIntegral) object+    _cb  object'++onNotebookMoveFocusOut :: (GObject a, MonadIO m) => a -> NotebookMoveFocusOutCallback -> m SignalHandlerId+onNotebookMoveFocusOut obj cb = liftIO $ connectNotebookMoveFocusOut obj cb SignalConnectBefore+afterNotebookMoveFocusOut :: (GObject a, MonadIO m) => a -> NotebookMoveFocusOutCallback -> m SignalHandlerId+afterNotebookMoveFocusOut obj cb = connectNotebookMoveFocusOut obj cb SignalConnectAfter++connectNotebookMoveFocusOut :: (GObject a, MonadIO m) =>+                               a -> NotebookMoveFocusOutCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookMoveFocusOut obj cb after = liftIO $ do+    cb' <- mkNotebookMoveFocusOutCallback (notebookMoveFocusOutCallbackWrapper cb)+    connectSignalFunPtr obj "move-focus-out" cb' after++-- signal Notebook::page-added+type NotebookPageAddedCallback =+    Widget ->+    Word32 ->+    IO ()++noNotebookPageAddedCallback :: Maybe NotebookPageAddedCallback+noNotebookPageAddedCallback = Nothing++type NotebookPageAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNotebookPageAddedCallback :: NotebookPageAddedCallbackC -> IO (FunPtr NotebookPageAddedCallbackC)++notebookPageAddedClosure :: NotebookPageAddedCallback -> IO Closure+notebookPageAddedClosure cb = newCClosure =<< mkNotebookPageAddedCallback wrapped+    where wrapped = notebookPageAddedCallbackWrapper cb++notebookPageAddedCallbackWrapper ::+    NotebookPageAddedCallback ->+    Ptr () ->+    Ptr Widget ->+    Word32 ->+    Ptr () ->+    IO ()+notebookPageAddedCallbackWrapper _cb _ child page_num _ = do+    child' <- (newObject Widget) child+    _cb  child' page_num++onNotebookPageAdded :: (GObject a, MonadIO m) => a -> NotebookPageAddedCallback -> m SignalHandlerId+onNotebookPageAdded obj cb = liftIO $ connectNotebookPageAdded obj cb SignalConnectBefore+afterNotebookPageAdded :: (GObject a, MonadIO m) => a -> NotebookPageAddedCallback -> m SignalHandlerId+afterNotebookPageAdded obj cb = connectNotebookPageAdded obj cb SignalConnectAfter++connectNotebookPageAdded :: (GObject a, MonadIO m) =>+                            a -> NotebookPageAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookPageAdded obj cb after = liftIO $ do+    cb' <- mkNotebookPageAddedCallback (notebookPageAddedCallbackWrapper cb)+    connectSignalFunPtr obj "page-added" cb' after++-- signal Notebook::page-removed+type NotebookPageRemovedCallback =+    Widget ->+    Word32 ->+    IO ()++noNotebookPageRemovedCallback :: Maybe NotebookPageRemovedCallback+noNotebookPageRemovedCallback = Nothing++type NotebookPageRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNotebookPageRemovedCallback :: NotebookPageRemovedCallbackC -> IO (FunPtr NotebookPageRemovedCallbackC)++notebookPageRemovedClosure :: NotebookPageRemovedCallback -> IO Closure+notebookPageRemovedClosure cb = newCClosure =<< mkNotebookPageRemovedCallback wrapped+    where wrapped = notebookPageRemovedCallbackWrapper cb++notebookPageRemovedCallbackWrapper ::+    NotebookPageRemovedCallback ->+    Ptr () ->+    Ptr Widget ->+    Word32 ->+    Ptr () ->+    IO ()+notebookPageRemovedCallbackWrapper _cb _ child page_num _ = do+    child' <- (newObject Widget) child+    _cb  child' page_num++onNotebookPageRemoved :: (GObject a, MonadIO m) => a -> NotebookPageRemovedCallback -> m SignalHandlerId+onNotebookPageRemoved obj cb = liftIO $ connectNotebookPageRemoved obj cb SignalConnectBefore+afterNotebookPageRemoved :: (GObject a, MonadIO m) => a -> NotebookPageRemovedCallback -> m SignalHandlerId+afterNotebookPageRemoved obj cb = connectNotebookPageRemoved obj cb SignalConnectAfter++connectNotebookPageRemoved :: (GObject a, MonadIO m) =>+                              a -> NotebookPageRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookPageRemoved obj cb after = liftIO $ do+    cb' <- mkNotebookPageRemovedCallback (notebookPageRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "page-removed" cb' after++-- signal Notebook::page-reordered+type NotebookPageReorderedCallback =+    Widget ->+    Word32 ->+    IO ()++noNotebookPageReorderedCallback :: Maybe NotebookPageReorderedCallback+noNotebookPageReorderedCallback = Nothing++type NotebookPageReorderedCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNotebookPageReorderedCallback :: NotebookPageReorderedCallbackC -> IO (FunPtr NotebookPageReorderedCallbackC)++notebookPageReorderedClosure :: NotebookPageReorderedCallback -> IO Closure+notebookPageReorderedClosure cb = newCClosure =<< mkNotebookPageReorderedCallback wrapped+    where wrapped = notebookPageReorderedCallbackWrapper cb++notebookPageReorderedCallbackWrapper ::+    NotebookPageReorderedCallback ->+    Ptr () ->+    Ptr Widget ->+    Word32 ->+    Ptr () ->+    IO ()+notebookPageReorderedCallbackWrapper _cb _ child page_num _ = do+    child' <- (newObject Widget) child+    _cb  child' page_num++onNotebookPageReordered :: (GObject a, MonadIO m) => a -> NotebookPageReorderedCallback -> m SignalHandlerId+onNotebookPageReordered obj cb = liftIO $ connectNotebookPageReordered obj cb SignalConnectBefore+afterNotebookPageReordered :: (GObject a, MonadIO m) => a -> NotebookPageReorderedCallback -> m SignalHandlerId+afterNotebookPageReordered obj cb = connectNotebookPageReordered obj cb SignalConnectAfter++connectNotebookPageReordered :: (GObject a, MonadIO m) =>+                                a -> NotebookPageReorderedCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookPageReordered obj cb after = liftIO $ do+    cb' <- mkNotebookPageReorderedCallback (notebookPageReorderedCallbackWrapper cb)+    connectSignalFunPtr obj "page-reordered" cb' after++-- signal Notebook::reorder-tab+type NotebookReorderTabCallback =+    DirectionType ->+    Bool ->+    IO Bool++noNotebookReorderTabCallback :: Maybe NotebookReorderTabCallback+noNotebookReorderTabCallback = Nothing++type NotebookReorderTabCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    CInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkNotebookReorderTabCallback :: NotebookReorderTabCallbackC -> IO (FunPtr NotebookReorderTabCallbackC)++notebookReorderTabClosure :: NotebookReorderTabCallback -> IO Closure+notebookReorderTabClosure cb = newCClosure =<< mkNotebookReorderTabCallback wrapped+    where wrapped = notebookReorderTabCallbackWrapper cb++notebookReorderTabCallbackWrapper ::+    NotebookReorderTabCallback ->+    Ptr () ->+    CUInt ->+    CInt ->+    Ptr () ->+    IO CInt+notebookReorderTabCallbackWrapper _cb _ object p0 _ = do+    let object' = (toEnum . fromIntegral) object+    let p0' = (/= 0) p0+    result <- _cb  object' p0'+    let result' = (fromIntegral . fromEnum) result+    return result'++onNotebookReorderTab :: (GObject a, MonadIO m) => a -> NotebookReorderTabCallback -> m SignalHandlerId+onNotebookReorderTab obj cb = liftIO $ connectNotebookReorderTab obj cb SignalConnectBefore+afterNotebookReorderTab :: (GObject a, MonadIO m) => a -> NotebookReorderTabCallback -> m SignalHandlerId+afterNotebookReorderTab obj cb = connectNotebookReorderTab obj cb SignalConnectAfter++connectNotebookReorderTab :: (GObject a, MonadIO m) =>+                             a -> NotebookReorderTabCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookReorderTab obj cb after = liftIO $ do+    cb' <- mkNotebookReorderTabCallback (notebookReorderTabCallbackWrapper cb)+    connectSignalFunPtr obj "reorder-tab" cb' after++-- signal Notebook::select-page+type NotebookSelectPageCallback =+    Bool ->+    IO Bool++noNotebookSelectPageCallback :: Maybe NotebookSelectPageCallback+noNotebookSelectPageCallback = Nothing++type NotebookSelectPageCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkNotebookSelectPageCallback :: NotebookSelectPageCallbackC -> IO (FunPtr NotebookSelectPageCallbackC)++notebookSelectPageClosure :: NotebookSelectPageCallback -> IO Closure+notebookSelectPageClosure cb = newCClosure =<< mkNotebookSelectPageCallback wrapped+    where wrapped = notebookSelectPageCallbackWrapper cb++notebookSelectPageCallbackWrapper ::+    NotebookSelectPageCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO CInt+notebookSelectPageCallbackWrapper _cb _ object _ = do+    let object' = (/= 0) object+    result <- _cb  object'+    let result' = (fromIntegral . fromEnum) result+    return result'++onNotebookSelectPage :: (GObject a, MonadIO m) => a -> NotebookSelectPageCallback -> m SignalHandlerId+onNotebookSelectPage obj cb = liftIO $ connectNotebookSelectPage obj cb SignalConnectBefore+afterNotebookSelectPage :: (GObject a, MonadIO m) => a -> NotebookSelectPageCallback -> m SignalHandlerId+afterNotebookSelectPage obj cb = connectNotebookSelectPage obj cb SignalConnectAfter++connectNotebookSelectPage :: (GObject a, MonadIO m) =>+                             a -> NotebookSelectPageCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookSelectPage obj cb after = liftIO $ do+    cb' <- mkNotebookSelectPageCallback (notebookSelectPageCallbackWrapper cb)+    connectSignalFunPtr obj "select-page" cb' after++-- signal Notebook::switch-page+type NotebookSwitchPageCallback =+    Widget ->+    Word32 ->+    IO ()++noNotebookSwitchPageCallback :: Maybe NotebookSwitchPageCallback+noNotebookSwitchPageCallback = Nothing++type NotebookSwitchPageCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Word32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkNotebookSwitchPageCallback :: NotebookSwitchPageCallbackC -> IO (FunPtr NotebookSwitchPageCallbackC)++notebookSwitchPageClosure :: NotebookSwitchPageCallback -> IO Closure+notebookSwitchPageClosure cb = newCClosure =<< mkNotebookSwitchPageCallback wrapped+    where wrapped = notebookSwitchPageCallbackWrapper cb++notebookSwitchPageCallbackWrapper ::+    NotebookSwitchPageCallback ->+    Ptr () ->+    Ptr Widget ->+    Word32 ->+    Ptr () ->+    IO ()+notebookSwitchPageCallbackWrapper _cb _ page page_num _ = do+    page' <- (newObject Widget) page+    _cb  page' page_num++onNotebookSwitchPage :: (GObject a, MonadIO m) => a -> NotebookSwitchPageCallback -> m SignalHandlerId+onNotebookSwitchPage obj cb = liftIO $ connectNotebookSwitchPage obj cb SignalConnectBefore+afterNotebookSwitchPage :: (GObject a, MonadIO m) => a -> NotebookSwitchPageCallback -> m SignalHandlerId+afterNotebookSwitchPage obj cb = connectNotebookSwitchPage obj cb SignalConnectAfter++connectNotebookSwitchPage :: (GObject a, MonadIO m) =>+                             a -> NotebookSwitchPageCallback -> SignalConnectMode -> m SignalHandlerId+connectNotebookSwitchPage obj cb after = liftIO $ do+    cb' <- mkNotebookSwitchPageCallback (notebookSwitchPageCallbackWrapper cb)+    connectSignalFunPtr obj "switch-page" cb' after++-- VVV Prop "enable-popup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookEnablePopup :: (MonadIO m, NotebookK o) => o -> m Bool+getNotebookEnablePopup obj = liftIO $ getObjectPropertyBool obj "enable-popup"++setNotebookEnablePopup :: (MonadIO m, NotebookK o) => o -> Bool -> m ()+setNotebookEnablePopup obj val = liftIO $ setObjectPropertyBool obj "enable-popup" val++constructNotebookEnablePopup :: Bool -> IO ([Char], GValue)+constructNotebookEnablePopup val = constructObjectPropertyBool "enable-popup" val++data NotebookEnablePopupPropertyInfo+instance AttrInfo NotebookEnablePopupPropertyInfo where+    type AttrAllowedOps NotebookEnablePopupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookEnablePopupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint NotebookEnablePopupPropertyInfo = NotebookK+    type AttrGetType NotebookEnablePopupPropertyInfo = Bool+    type AttrLabel NotebookEnablePopupPropertyInfo = "Notebook::enable-popup"+    attrGet _ = getNotebookEnablePopup+    attrSet _ = setNotebookEnablePopup+    attrConstruct _ = constructNotebookEnablePopup++-- VVV Prop "group-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookGroupName :: (MonadIO m, NotebookK o) => o -> m T.Text+getNotebookGroupName obj = liftIO $ getObjectPropertyString obj "group-name"++setNotebookGroupName :: (MonadIO m, NotebookK o) => o -> T.Text -> m ()+setNotebookGroupName obj val = liftIO $ setObjectPropertyString obj "group-name" val++constructNotebookGroupName :: T.Text -> IO ([Char], GValue)+constructNotebookGroupName val = constructObjectPropertyString "group-name" val++data NotebookGroupNamePropertyInfo+instance AttrInfo NotebookGroupNamePropertyInfo where+    type AttrAllowedOps NotebookGroupNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookGroupNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NotebookGroupNamePropertyInfo = NotebookK+    type AttrGetType NotebookGroupNamePropertyInfo = T.Text+    type AttrLabel NotebookGroupNamePropertyInfo = "Notebook::group-name"+    attrGet _ = getNotebookGroupName+    attrSet _ = setNotebookGroupName+    attrConstruct _ = constructNotebookGroupName++-- VVV Prop "page"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookPage :: (MonadIO m, NotebookK o) => o -> m Int32+getNotebookPage obj = liftIO $ getObjectPropertyCInt obj "page"++setNotebookPage :: (MonadIO m, NotebookK o) => o -> Int32 -> m ()+setNotebookPage obj val = liftIO $ setObjectPropertyCInt obj "page" val++constructNotebookPage :: Int32 -> IO ([Char], GValue)+constructNotebookPage val = constructObjectPropertyCInt "page" val++data NotebookPagePropertyInfo+instance AttrInfo NotebookPagePropertyInfo where+    type AttrAllowedOps NotebookPagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookPagePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint NotebookPagePropertyInfo = NotebookK+    type AttrGetType NotebookPagePropertyInfo = Int32+    type AttrLabel NotebookPagePropertyInfo = "Notebook::page"+    attrGet _ = getNotebookPage+    attrSet _ = setNotebookPage+    attrConstruct _ = constructNotebookPage++-- VVV Prop "scrollable"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookScrollable :: (MonadIO m, NotebookK o) => o -> m Bool+getNotebookScrollable obj = liftIO $ getObjectPropertyBool obj "scrollable"++setNotebookScrollable :: (MonadIO m, NotebookK o) => o -> Bool -> m ()+setNotebookScrollable obj val = liftIO $ setObjectPropertyBool obj "scrollable" val++constructNotebookScrollable :: Bool -> IO ([Char], GValue)+constructNotebookScrollable val = constructObjectPropertyBool "scrollable" val++data NotebookScrollablePropertyInfo+instance AttrInfo NotebookScrollablePropertyInfo where+    type AttrAllowedOps NotebookScrollablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookScrollablePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint NotebookScrollablePropertyInfo = NotebookK+    type AttrGetType NotebookScrollablePropertyInfo = Bool+    type AttrLabel NotebookScrollablePropertyInfo = "Notebook::scrollable"+    attrGet _ = getNotebookScrollable+    attrSet _ = setNotebookScrollable+    attrConstruct _ = constructNotebookScrollable++-- VVV Prop "show-border"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookShowBorder :: (MonadIO m, NotebookK o) => o -> m Bool+getNotebookShowBorder obj = liftIO $ getObjectPropertyBool obj "show-border"++setNotebookShowBorder :: (MonadIO m, NotebookK o) => o -> Bool -> m ()+setNotebookShowBorder obj val = liftIO $ setObjectPropertyBool obj "show-border" val++constructNotebookShowBorder :: Bool -> IO ([Char], GValue)+constructNotebookShowBorder val = constructObjectPropertyBool "show-border" val++data NotebookShowBorderPropertyInfo+instance AttrInfo NotebookShowBorderPropertyInfo where+    type AttrAllowedOps NotebookShowBorderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookShowBorderPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint NotebookShowBorderPropertyInfo = NotebookK+    type AttrGetType NotebookShowBorderPropertyInfo = Bool+    type AttrLabel NotebookShowBorderPropertyInfo = "Notebook::show-border"+    attrGet _ = getNotebookShowBorder+    attrSet _ = setNotebookShowBorder+    attrConstruct _ = constructNotebookShowBorder++-- VVV Prop "show-tabs"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookShowTabs :: (MonadIO m, NotebookK o) => o -> m Bool+getNotebookShowTabs obj = liftIO $ getObjectPropertyBool obj "show-tabs"++setNotebookShowTabs :: (MonadIO m, NotebookK o) => o -> Bool -> m ()+setNotebookShowTabs obj val = liftIO $ setObjectPropertyBool obj "show-tabs" val++constructNotebookShowTabs :: Bool -> IO ([Char], GValue)+constructNotebookShowTabs val = constructObjectPropertyBool "show-tabs" val++data NotebookShowTabsPropertyInfo+instance AttrInfo NotebookShowTabsPropertyInfo where+    type AttrAllowedOps NotebookShowTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookShowTabsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint NotebookShowTabsPropertyInfo = NotebookK+    type AttrGetType NotebookShowTabsPropertyInfo = Bool+    type AttrLabel NotebookShowTabsPropertyInfo = "Notebook::show-tabs"+    attrGet _ = getNotebookShowTabs+    attrSet _ = setNotebookShowTabs+    attrConstruct _ = constructNotebookShowTabs++-- VVV Prop "tab-pos"+   -- Type: TInterface "Gtk" "PositionType"+   -- Flags: [PropertyReadable,PropertyWritable]++getNotebookTabPos :: (MonadIO m, NotebookK o) => o -> m PositionType+getNotebookTabPos obj = liftIO $ getObjectPropertyEnum obj "tab-pos"++setNotebookTabPos :: (MonadIO m, NotebookK o) => o -> PositionType -> m ()+setNotebookTabPos obj val = liftIO $ setObjectPropertyEnum obj "tab-pos" val++constructNotebookTabPos :: PositionType -> IO ([Char], GValue)+constructNotebookTabPos val = constructObjectPropertyEnum "tab-pos" val++data NotebookTabPosPropertyInfo+instance AttrInfo NotebookTabPosPropertyInfo where+    type AttrAllowedOps NotebookTabPosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NotebookTabPosPropertyInfo = (~) PositionType+    type AttrBaseTypeConstraint NotebookTabPosPropertyInfo = NotebookK+    type AttrGetType NotebookTabPosPropertyInfo = PositionType+    type AttrLabel NotebookTabPosPropertyInfo = "Notebook::tab-pos"+    attrGet _ = getNotebookTabPos+    attrSet _ = setNotebookTabPos+    attrConstruct _ = constructNotebookTabPos++type instance AttributeList Notebook = NotebookAttributeList+type NotebookAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("enable-popup", NotebookEnablePopupPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("group-name", NotebookGroupNamePropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("page", NotebookPagePropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("scrollable", NotebookScrollablePropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-border", NotebookShowBorderPropertyInfo), '("show-tabs", NotebookShowTabsPropertyInfo), '("style", WidgetStylePropertyInfo), '("tab-pos", NotebookTabPosPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data NotebookChangeCurrentPageSignalInfo+instance SignalInfo NotebookChangeCurrentPageSignalInfo where+    type HaskellCallbackType NotebookChangeCurrentPageSignalInfo = NotebookChangeCurrentPageCallback+    connectSignal _ = connectNotebookChangeCurrentPage++data NotebookCreateWindowSignalInfo+instance SignalInfo NotebookCreateWindowSignalInfo where+    type HaskellCallbackType NotebookCreateWindowSignalInfo = NotebookCreateWindowCallback+    connectSignal _ = connectNotebookCreateWindow++data NotebookFocusTabSignalInfo+instance SignalInfo NotebookFocusTabSignalInfo where+    type HaskellCallbackType NotebookFocusTabSignalInfo = NotebookFocusTabCallback+    connectSignal _ = connectNotebookFocusTab++data NotebookMoveFocusOutSignalInfo+instance SignalInfo NotebookMoveFocusOutSignalInfo where+    type HaskellCallbackType NotebookMoveFocusOutSignalInfo = NotebookMoveFocusOutCallback+    connectSignal _ = connectNotebookMoveFocusOut++data NotebookPageAddedSignalInfo+instance SignalInfo NotebookPageAddedSignalInfo where+    type HaskellCallbackType NotebookPageAddedSignalInfo = NotebookPageAddedCallback+    connectSignal _ = connectNotebookPageAdded++data NotebookPageRemovedSignalInfo+instance SignalInfo NotebookPageRemovedSignalInfo where+    type HaskellCallbackType NotebookPageRemovedSignalInfo = NotebookPageRemovedCallback+    connectSignal _ = connectNotebookPageRemoved++data NotebookPageReorderedSignalInfo+instance SignalInfo NotebookPageReorderedSignalInfo where+    type HaskellCallbackType NotebookPageReorderedSignalInfo = NotebookPageReorderedCallback+    connectSignal _ = connectNotebookPageReordered++data NotebookReorderTabSignalInfo+instance SignalInfo NotebookReorderTabSignalInfo where+    type HaskellCallbackType NotebookReorderTabSignalInfo = NotebookReorderTabCallback+    connectSignal _ = connectNotebookReorderTab++data NotebookSelectPageSignalInfo+instance SignalInfo NotebookSelectPageSignalInfo where+    type HaskellCallbackType NotebookSelectPageSignalInfo = NotebookSelectPageCallback+    connectSignal _ = connectNotebookSelectPage++data NotebookSwitchPageSignalInfo+instance SignalInfo NotebookSwitchPageSignalInfo where+    type HaskellCallbackType NotebookSwitchPageSignalInfo = NotebookSwitchPageCallback+    connectSignal _ = connectNotebookSwitchPage++type instance SignalList Notebook = NotebookSignalList+type NotebookSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("change-current-page", NotebookChangeCurrentPageSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("create-window", NotebookCreateWindowSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("focus-tab", NotebookFocusTabSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-focus-out", NotebookMoveFocusOutSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("page-added", NotebookPageAddedSignalInfo), '("page-removed", NotebookPageRemovedSignalInfo), '("page-reordered", NotebookPageReorderedSignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("reorder-tab", NotebookReorderTabSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select-page", NotebookSelectPageSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("switch-page", NotebookSwitchPageSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Notebook::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Notebook"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_new" gtk_notebook_new :: +    IO (Ptr Notebook)+++notebookNew ::+    (MonadIO m) =>+    m Notebook+notebookNew  = liftIO $ do+    result <- gtk_notebook_new+    checkUnexpectedReturnNULL "gtk_notebook_new" result+    result' <- (newObject Notebook) result+    return result'++-- method Notebook::append_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_append_page" gtk_notebook_append_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    IO Int32+++notebookAppendPage ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    m Int32+notebookAppendPage _obj child tab_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    result <- gtk_notebook_append_page _obj' child' maybeTab_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    return result++-- method Notebook::append_page_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_append_page_menu" gtk_notebook_append_page_menu :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- menu_label : TInterface "Gtk" "Widget"+    IO Int32+++notebookAppendPageMenu ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c, WidgetK d) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    Maybe (d) ->                            -- menu_label+    m Int32+notebookAppendPageMenu _obj child tab_label menu_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    maybeMenu_label <- case menu_label of+        Nothing -> return nullPtr+        Just jMenu_label -> do+            let jMenu_label' = unsafeManagedPtrCastPtr jMenu_label+            return jMenu_label'+    result <- gtk_notebook_append_page_menu _obj' child' maybeTab_label maybeMenu_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    whenJust menu_label touchManagedPtr+    return result++-- method Notebook::detach_tab+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_detach_tab" gtk_notebook_detach_tab :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++notebookDetachTab ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+notebookDetachTab _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_notebook_detach_tab _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Notebook::get_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_action_widget" gtk_notebook_get_action_widget :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CUInt ->                                -- pack_type : TInterface "Gtk" "PackType"+    IO (Ptr Widget)+++notebookGetActionWidget ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    PackType ->                             -- pack_type+    m Widget+notebookGetActionWidget _obj pack_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pack_type' = (fromIntegral . fromEnum) pack_type+    result <- gtk_notebook_get_action_widget _obj' pack_type'+    checkUnexpectedReturnNULL "gtk_notebook_get_action_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_current_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_current_page" gtk_notebook_get_current_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO Int32+++notebookGetCurrentPage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Int32+notebookGetCurrentPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_current_page _obj'+    touchManagedPtr _obj+    return result++-- method Notebook::get_group_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_group_name" gtk_notebook_get_group_name :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO CString+++notebookGetGroupName ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m T.Text+notebookGetGroupName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_group_name _obj'+    checkUnexpectedReturnNULL "gtk_notebook_get_group_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_menu_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_menu_label" gtk_notebook_get_menu_label :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO (Ptr Widget)+++notebookGetMenuLabel ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Widget+notebookGetMenuLabel _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_menu_label _obj' child'+    checkUnexpectedReturnNULL "gtk_notebook_get_menu_label" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_menu_label_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_menu_label_text" gtk_notebook_get_menu_label_text :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CString+++notebookGetMenuLabelText ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m T.Text+notebookGetMenuLabelText _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_menu_label_text _obj' child'+    checkUnexpectedReturnNULL "gtk_notebook_get_menu_label_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_n_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_n_pages" gtk_notebook_get_n_pages :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO Int32+++notebookGetNPages ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Int32+notebookGetNPages _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_n_pages _obj'+    touchManagedPtr _obj+    return result++-- method Notebook::get_nth_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_nth_page" gtk_notebook_get_nth_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO (Ptr Widget)+++notebookGetNthPage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m Widget+notebookGetNthPage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_nth_page _obj' page_num+    checkUnexpectedReturnNULL "gtk_notebook_get_nth_page" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_scrollable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_scrollable" gtk_notebook_get_scrollable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO CInt+++notebookGetScrollable ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Bool+notebookGetScrollable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_scrollable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_show_border+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_show_border" gtk_notebook_get_show_border :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO CInt+++notebookGetShowBorder ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Bool+notebookGetShowBorder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_show_border _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_show_tabs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_show_tabs" gtk_notebook_get_show_tabs :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO CInt+++notebookGetShowTabs ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Bool+notebookGetShowTabs _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_show_tabs _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_tab_detachable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_detachable" gtk_notebook_get_tab_detachable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CInt+++notebookGetTabDetachable ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Bool+notebookGetTabDetachable _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_tab_detachable _obj' child'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_tab_hborder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_hborder" gtk_notebook_get_tab_hborder :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO Word16++{-# DEPRECATED notebookGetTabHborder ["(Since version 3.4)","this function returns zero"]#-}+notebookGetTabHborder ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Word16+notebookGetTabHborder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_tab_hborder _obj'+    touchManagedPtr _obj+    return result++-- method Notebook::get_tab_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_label" gtk_notebook_get_tab_label :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO (Ptr Widget)+++notebookGetTabLabel ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Widget+notebookGetTabLabel _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_tab_label _obj' child'+    checkUnexpectedReturnNULL "gtk_notebook_get_tab_label" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_tab_label_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_label_text" gtk_notebook_get_tab_label_text :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CString+++notebookGetTabLabelText ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m T.Text+notebookGetTabLabelText _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_tab_label_text _obj' child'+    checkUnexpectedReturnNULL "gtk_notebook_get_tab_label_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_tab_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PositionType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_pos" gtk_notebook_get_tab_pos :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO CUInt+++notebookGetTabPos ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m PositionType+notebookGetTabPos _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_tab_pos _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Notebook::get_tab_reorderable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_reorderable" gtk_notebook_get_tab_reorderable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO CInt+++notebookGetTabReorderable ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Bool+notebookGetTabReorderable _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_get_tab_reorderable _obj' child'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr child+    return result'++-- method Notebook::get_tab_vborder+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt16+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_get_tab_vborder" gtk_notebook_get_tab_vborder :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO Word16++{-# DEPRECATED notebookGetTabVborder ["(Since version 3.4)","this function returns zero"]#-}+notebookGetTabVborder ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m Word16+notebookGetTabVborder _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_notebook_get_tab_vborder _obj'+    touchManagedPtr _obj+    return result++-- method Notebook::insert_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_insert_page" gtk_notebook_insert_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO Int32+++notebookInsertPage ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    Int32 ->                                -- position+    m Int32+notebookInsertPage _obj child tab_label position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    result <- gtk_notebook_insert_page _obj' child' maybeTab_label position+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    return result++-- method Notebook::insert_page_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, 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 TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_insert_page_menu" gtk_notebook_insert_page_menu :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- menu_label : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO Int32+++notebookInsertPageMenu ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c, WidgetK d) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    Maybe (d) ->                            -- menu_label+    Int32 ->                                -- position+    m Int32+notebookInsertPageMenu _obj child tab_label menu_label position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    maybeMenu_label <- case menu_label of+        Nothing -> return nullPtr+        Just jMenu_label -> do+            let jMenu_label' = unsafeManagedPtrCastPtr jMenu_label+            return jMenu_label'+    result <- gtk_notebook_insert_page_menu _obj' child' maybeTab_label maybeMenu_label position+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    whenJust menu_label touchManagedPtr+    return result++-- method Notebook::next_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_next_page" gtk_notebook_next_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO ()+++notebookNextPage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m ()+notebookNextPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_next_page _obj'+    touchManagedPtr _obj+    return ()++-- method Notebook::page_num+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_page_num" gtk_notebook_page_num :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO Int32+++notebookPageNum ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m Int32+notebookPageNum _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_page_num _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return result++-- method Notebook::popup_disable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_popup_disable" gtk_notebook_popup_disable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO ()+++notebookPopupDisable ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m ()+notebookPopupDisable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_popup_disable _obj'+    touchManagedPtr _obj+    return ()++-- method Notebook::popup_enable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_popup_enable" gtk_notebook_popup_enable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO ()+++notebookPopupEnable ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m ()+notebookPopupEnable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_popup_enable _obj'+    touchManagedPtr _obj+    return ()++-- method Notebook::prepend_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_prepend_page" gtk_notebook_prepend_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    IO Int32+++notebookPrependPage ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    m Int32+notebookPrependPage _obj child tab_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    result <- gtk_notebook_prepend_page _obj' child' maybeTab_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    return result++-- method Notebook::prepend_page_menu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_prepend_page_menu" gtk_notebook_prepend_page_menu :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- menu_label : TInterface "Gtk" "Widget"+    IO Int32+++notebookPrependPageMenu ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c, WidgetK d) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    Maybe (d) ->                            -- menu_label+    m Int32+notebookPrependPageMenu _obj child tab_label menu_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    maybeMenu_label <- case menu_label of+        Nothing -> return nullPtr+        Just jMenu_label -> do+            let jMenu_label' = unsafeManagedPtrCastPtr jMenu_label+            return jMenu_label'+    result <- gtk_notebook_prepend_page_menu _obj' child' maybeTab_label maybeMenu_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    whenJust menu_label touchManagedPtr+    return result++-- method Notebook::prev_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_prev_page" gtk_notebook_prev_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    IO ()+++notebookPrevPage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    m ()+notebookPrevPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_prev_page _obj'+    touchManagedPtr _obj+    return ()++-- method Notebook::remove_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_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 "gtk_notebook_remove_page" gtk_notebook_remove_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO ()+++notebookRemovePage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m ()+notebookRemovePage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_remove_page _obj' page_num+    touchManagedPtr _obj+    return ()++-- method Notebook::reorder_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_notebook_reorder_child" gtk_notebook_reorder_child :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++notebookReorderChild ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+notebookReorderChild _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_notebook_reorder_child _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Notebook::set_action_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pack_type", argType = TInterface "Gtk" "PackType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_set_action_widget" gtk_notebook_set_action_widget :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CUInt ->                                -- pack_type : TInterface "Gtk" "PackType"+    IO ()+++notebookSetActionWidget ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    PackType ->                             -- pack_type+    m ()+notebookSetActionWidget _obj widget pack_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let pack_type' = (fromIntegral . fromEnum) pack_type+    gtk_notebook_set_action_widget _obj' widget' pack_type'+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method Notebook::set_current_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_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 "gtk_notebook_set_current_page" gtk_notebook_set_current_page :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Int32 ->                                -- page_num : TBasicType TInt32+    IO ()+++notebookSetCurrentPage ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- page_num+    m ()+notebookSetCurrentPage _obj page_num = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_set_current_page _obj' page_num+    touchManagedPtr _obj+    return ()++-- method Notebook::set_group_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", 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 "gtk_notebook_set_group_name" gtk_notebook_set_group_name :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CString ->                              -- group_name : TBasicType TUTF8+    IO ()+++notebookSetGroupName ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- group_name+    m ()+notebookSetGroupName _obj group_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeGroup_name <- case group_name of+        Nothing -> return nullPtr+        Just jGroup_name -> do+            jGroup_name' <- textToCString jGroup_name+            return jGroup_name'+    gtk_notebook_set_group_name _obj' maybeGroup_name+    touchManagedPtr _obj+    freeMem maybeGroup_name+    return ()++-- method Notebook::set_menu_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_set_menu_label" gtk_notebook_set_menu_label :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- menu_label : TInterface "Gtk" "Widget"+    IO ()+++notebookSetMenuLabel ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- menu_label+    m ()+notebookSetMenuLabel _obj child menu_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeMenu_label <- case menu_label of+        Nothing -> return nullPtr+        Just jMenu_label -> do+            let jMenu_label' = unsafeManagedPtrCastPtr jMenu_label+            return jMenu_label'+    gtk_notebook_set_menu_label _obj' child' maybeMenu_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust menu_label touchManagedPtr+    return ()++-- method Notebook::set_menu_label_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "menu_text", 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 "gtk_notebook_set_menu_label_text" gtk_notebook_set_menu_label_text :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CString ->                              -- menu_text : TBasicType TUTF8+    IO ()+++notebookSetMenuLabelText ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    T.Text ->                               -- menu_text+    m ()+notebookSetMenuLabelText _obj child menu_text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    menu_text' <- textToCString menu_text+    gtk_notebook_set_menu_label_text _obj' child' menu_text'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem menu_text'+    return ()++-- method Notebook::set_scrollable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scrollable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scrollable", 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 "gtk_notebook_set_scrollable" gtk_notebook_set_scrollable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CInt ->                                 -- scrollable : TBasicType TBoolean+    IO ()+++notebookSetScrollable ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- scrollable+    m ()+notebookSetScrollable _obj scrollable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let scrollable' = (fromIntegral . fromEnum) scrollable+    gtk_notebook_set_scrollable _obj' scrollable'+    touchManagedPtr _obj+    return ()++-- method Notebook::set_show_border+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_border", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_border", 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 "gtk_notebook_set_show_border" gtk_notebook_set_show_border :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CInt ->                                 -- show_border : TBasicType TBoolean+    IO ()+++notebookSetShowBorder ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_border+    m ()+notebookSetShowBorder _obj show_border = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_border' = (fromIntegral . fromEnum) show_border+    gtk_notebook_set_show_border _obj' show_border'+    touchManagedPtr _obj+    return ()++-- method Notebook::set_show_tabs+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_tabs", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_tabs", 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 "gtk_notebook_set_show_tabs" gtk_notebook_set_show_tabs :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CInt ->                                 -- show_tabs : TBasicType TBoolean+    IO ()+++notebookSetShowTabs ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_tabs+    m ()+notebookSetShowTabs _obj show_tabs = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_tabs' = (fromIntegral . fromEnum) show_tabs+    gtk_notebook_set_show_tabs _obj' show_tabs'+    touchManagedPtr _obj+    return ()++-- method Notebook::set_tab_detachable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detachable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "detachable", 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 "gtk_notebook_set_tab_detachable" gtk_notebook_set_tab_detachable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- detachable : TBasicType TBoolean+    IO ()+++notebookSetTabDetachable ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- detachable+    m ()+notebookSetTabDetachable _obj child detachable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let detachable' = (fromIntegral . fromEnum) detachable+    gtk_notebook_set_tab_detachable _obj' child' detachable'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Notebook::set_tab_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_label", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_set_tab_label" gtk_notebook_set_tab_label :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Ptr Widget ->                           -- tab_label : TInterface "Gtk" "Widget"+    IO ()+++notebookSetTabLabel ::+    (MonadIO m, NotebookK a, WidgetK b, WidgetK c) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Maybe (c) ->                            -- tab_label+    m ()+notebookSetTabLabel _obj child tab_label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    maybeTab_label <- case tab_label of+        Nothing -> return nullPtr+        Just jTab_label -> do+            let jTab_label' = unsafeManagedPtrCastPtr jTab_label+            return jTab_label'+    gtk_notebook_set_tab_label _obj' child' maybeTab_label+    touchManagedPtr _obj+    touchManagedPtr child+    whenJust tab_label touchManagedPtr+    return ()++-- method Notebook::set_tab_label_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tab_text", 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 "gtk_notebook_set_tab_label_text" gtk_notebook_set_tab_label_text :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CString ->                              -- tab_text : TBasicType TUTF8+    IO ()+++notebookSetTabLabelText ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    T.Text ->                               -- tab_text+    m ()+notebookSetTabLabelText _obj child tab_text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    tab_text' <- textToCString tab_text+    gtk_notebook_set_tab_label_text _obj' child' tab_text'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem tab_text'+    return ()++-- method Notebook::set_tab_pos+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pos", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_set_tab_pos" gtk_notebook_set_tab_pos :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    CUInt ->                                -- pos : TInterface "Gtk" "PositionType"+    IO ()+++notebookSetTabPos ::+    (MonadIO m, NotebookK a) =>+    a ->                                    -- _obj+    PositionType ->                         -- pos+    m ()+notebookSetTabPos _obj pos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pos' = (fromIntegral . fromEnum) pos+    gtk_notebook_set_tab_pos _obj' pos'+    touchManagedPtr _obj+    return ()++-- method Notebook::set_tab_reorderable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reorderable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Notebook", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reorderable", 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 "gtk_notebook_set_tab_reorderable" gtk_notebook_set_tab_reorderable :: +    Ptr Notebook ->                         -- _obj : TInterface "Gtk" "Notebook"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- reorderable : TBasicType TBoolean+    IO ()+++notebookSetTabReorderable ::+    (MonadIO m, NotebookK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- reorderable+    m ()+notebookSetTabReorderable _obj child reorderable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let reorderable' = (fromIntegral . fromEnum) reorderable+    gtk_notebook_set_tab_reorderable _obj' child' reorderable'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++
+ GI/Gtk/Objects/Notebook.hs-boot view
@@ -0,0 +1,30 @@+module GI.Gtk.Objects.Notebook where++import Prelude ()+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 Notebook = Notebook (ForeignPtr Notebook)+instance GObject Notebook where+class GObject o => NotebookK o+instance (GObject o, IsDescendantOf Notebook o) => NotebookK o+data NotebookEnablePopupPropertyInfo+data NotebookGroupNamePropertyInfo+data NotebookPagePropertyInfo+data NotebookScrollablePropertyInfo+data NotebookShowBorderPropertyInfo+data NotebookShowTabsPropertyInfo+data NotebookTabPosPropertyInfo+data NotebookChangeCurrentPageSignalInfo+data NotebookCreateWindowSignalInfo+data NotebookFocusTabSignalInfo+data NotebookMoveFocusOutSignalInfo+data NotebookPageAddedSignalInfo+data NotebookPageRemovedSignalInfo+data NotebookPageReorderedSignalInfo+data NotebookReorderTabSignalInfo+data NotebookSelectPageSignalInfo+data NotebookSwitchPageSignalInfo
+ GI/Gtk/Objects/NotebookAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.NotebookAccessible+    ( ++-- * Exported types+    NotebookAccessible(..)                  ,+    NotebookAccessibleK                     ,+    toNotebookAccessible                    ,+    noNotebookAccessible                    ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype NotebookAccessible = NotebookAccessible (ForeignPtr NotebookAccessible)+foreign import ccall "gtk_notebook_accessible_get_type"+    c_gtk_notebook_accessible_get_type :: IO GType++type instance ParentTypes NotebookAccessible = NotebookAccessibleParentTypes+type NotebookAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Selection]++instance GObject NotebookAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_notebook_accessible_get_type+    ++class GObject o => NotebookAccessibleK o+instance (GObject o, IsDescendantOf NotebookAccessible o) => NotebookAccessibleK o++toNotebookAccessible :: NotebookAccessibleK o => o -> IO NotebookAccessible+toNotebookAccessible = unsafeCastTo NotebookAccessible++noNotebookAccessible :: Maybe NotebookAccessible+noNotebookAccessible = Nothing++type instance AttributeList NotebookAccessible = NotebookAccessibleAttributeList+type NotebookAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList NotebookAccessible = NotebookAccessibleSignalList+type NotebookAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/NotebookAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.NotebookAccessible where++import Prelude ()+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 NotebookAccessible = NotebookAccessible (ForeignPtr NotebookAccessible)+instance GObject NotebookAccessible where+class GObject o => NotebookAccessibleK o+instance (GObject o, IsDescendantOf NotebookAccessible o) => NotebookAccessibleK o
+ GI/Gtk/Objects/NotebookPageAccessible.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)+-}++module GI.Gtk.Objects.NotebookPageAccessible+    ( ++-- * Exported types+    NotebookPageAccessible(..)              ,+    NotebookPageAccessibleK                 ,+    toNotebookPageAccessible                ,+    noNotebookPageAccessible                ,+++ -- * Methods+-- ** notebookPageAccessibleInvalidate+    notebookPageAccessibleInvalidate        ,+++-- ** notebookPageAccessibleNew+    notebookPageAccessibleNew               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype NotebookPageAccessible = NotebookPageAccessible (ForeignPtr NotebookPageAccessible)+foreign import ccall "gtk_notebook_page_accessible_get_type"+    c_gtk_notebook_page_accessible_get_type :: IO GType++type instance ParentTypes NotebookPageAccessible = NotebookPageAccessibleParentTypes+type NotebookPageAccessibleParentTypes = '[Atk.Object, GObject.Object, Atk.Component]++instance GObject NotebookPageAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_notebook_page_accessible_get_type+    ++class GObject o => NotebookPageAccessibleK o+instance (GObject o, IsDescendantOf NotebookPageAccessible o) => NotebookPageAccessibleK o++toNotebookPageAccessible :: NotebookPageAccessibleK o => o -> IO NotebookPageAccessible+toNotebookPageAccessible = unsafeCastTo NotebookPageAccessible++noNotebookPageAccessible :: Maybe NotebookPageAccessible+noNotebookPageAccessible = Nothing++type instance AttributeList NotebookPageAccessible = NotebookPageAccessibleAttributeList+type NotebookPageAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo)] :: [(Symbol, *)])++type instance SignalList NotebookPageAccessible = NotebookPageAccessibleSignalList+type NotebookPageAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method NotebookPageAccessible::new+-- method type : Constructor+-- Args : [Arg {argName = "notebook", argType = TInterface "Gtk" "NotebookAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "notebook", argType = TInterface "Gtk" "NotebookAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "NotebookPageAccessible"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_page_accessible_new" gtk_notebook_page_accessible_new :: +    Ptr NotebookAccessible ->               -- notebook : TInterface "Gtk" "NotebookAccessible"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO (Ptr NotebookPageAccessible)+++notebookPageAccessibleNew ::+    (MonadIO m, NotebookAccessibleK a, WidgetK b) =>+    a ->                                    -- notebook+    b ->                                    -- child+    m NotebookPageAccessible+notebookPageAccessibleNew notebook child = liftIO $ do+    let notebook' = unsafeManagedPtrCastPtr notebook+    let child' = unsafeManagedPtrCastPtr child+    result <- gtk_notebook_page_accessible_new notebook' child'+    checkUnexpectedReturnNULL "gtk_notebook_page_accessible_new" result+    result' <- (wrapObject NotebookPageAccessible) result+    touchManagedPtr notebook+    touchManagedPtr child+    return result'++-- method NotebookPageAccessible::invalidate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NotebookPageAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NotebookPageAccessible", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_notebook_page_accessible_invalidate" gtk_notebook_page_accessible_invalidate :: +    Ptr NotebookPageAccessible ->           -- _obj : TInterface "Gtk" "NotebookPageAccessible"+    IO ()+++notebookPageAccessibleInvalidate ::+    (MonadIO m, NotebookPageAccessibleK a) =>+    a ->                                    -- _obj+    m ()+notebookPageAccessibleInvalidate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_notebook_page_accessible_invalidate _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/NotebookPageAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.NotebookPageAccessible where++import Prelude ()+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 NotebookPageAccessible = NotebookPageAccessible (ForeignPtr NotebookPageAccessible)+instance GObject NotebookPageAccessible where+class GObject o => NotebookPageAccessibleK o+instance (GObject o, IsDescendantOf NotebookPageAccessible o) => NotebookPageAccessibleK o
+ GI/Gtk/Objects/NumerableIcon.hs view
@@ -0,0 +1,602 @@++{- |+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.Gtk.Objects.NumerableIcon+    ( ++-- * Exported types+    NumerableIcon(..)                       ,+    NumerableIconK                          ,+    toNumerableIcon                         ,+    noNumerableIcon                         ,+++ -- * Methods+-- ** numerableIconGetBackgroundGicon+    numerableIconGetBackgroundGicon         ,+++-- ** numerableIconGetBackgroundIconName+    numerableIconGetBackgroundIconName      ,+++-- ** numerableIconGetCount+    numerableIconGetCount                   ,+++-- ** numerableIconGetLabel+    numerableIconGetLabel                   ,+++-- ** numerableIconGetStyleContext+    numerableIconGetStyleContext            ,+++-- ** numerableIconNew+    numerableIconNew                        ,+++-- ** numerableIconNewWithStyleContext+    numerableIconNewWithStyleContext        ,+++-- ** numerableIconSetBackgroundGicon+    numerableIconSetBackgroundGicon         ,+++-- ** numerableIconSetBackgroundIconName+    numerableIconSetBackgroundIconName      ,+++-- ** numerableIconSetCount+    numerableIconSetCount                   ,+++-- ** numerableIconSetLabel+    numerableIconSetLabel                   ,+++-- ** numerableIconSetStyleContext+    numerableIconSetStyleContext            ,+++++ -- * Properties+-- ** BackgroundIcon+    NumerableIconBackgroundIconPropertyInfo ,+    constructNumerableIconBackgroundIcon    ,+    getNumerableIconBackgroundIcon          ,+    setNumerableIconBackgroundIcon          ,+++-- ** BackgroundIconName+    NumerableIconBackgroundIconNamePropertyInfo,+    constructNumerableIconBackgroundIconName,+    getNumerableIconBackgroundIconName      ,+    setNumerableIconBackgroundIconName      ,+++-- ** Count+    NumerableIconCountPropertyInfo          ,+    constructNumerableIconCount             ,+    getNumerableIconCount                   ,+    setNumerableIconCount                   ,+++-- ** Label+    NumerableIconLabelPropertyInfo          ,+    constructNumerableIconLabel             ,+    getNumerableIconLabel                   ,+    setNumerableIconLabel                   ,+++-- ** StyleContext+    NumerableIconStyleContextPropertyInfo   ,+    constructNumerableIconStyleContext      ,+    getNumerableIconStyleContext            ,+    setNumerableIconStyleContext            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype NumerableIcon = NumerableIcon (ForeignPtr NumerableIcon)+foreign import ccall "gtk_numerable_icon_get_type"+    c_gtk_numerable_icon_get_type :: IO GType++type instance ParentTypes NumerableIcon = NumerableIconParentTypes+type NumerableIconParentTypes = '[Gio.EmblemedIcon, GObject.Object, Gio.Icon]++instance GObject NumerableIcon where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_numerable_icon_get_type+    ++class GObject o => NumerableIconK o+instance (GObject o, IsDescendantOf NumerableIcon o) => NumerableIconK o++toNumerableIcon :: NumerableIconK o => o -> IO NumerableIcon+toNumerableIcon = unsafeCastTo NumerableIcon++noNumerableIcon :: Maybe NumerableIcon+noNumerableIcon = Nothing++-- VVV Prop "background-icon"+   -- Type: TInterface "Gio" "Icon"+   -- Flags: [PropertyReadable,PropertyWritable]++getNumerableIconBackgroundIcon :: (MonadIO m, NumerableIconK o) => o -> m Gio.Icon+getNumerableIconBackgroundIcon obj = liftIO $ getObjectPropertyObject obj "background-icon" Gio.Icon++setNumerableIconBackgroundIcon :: (MonadIO m, NumerableIconK o, Gio.IconK a) => o -> a -> m ()+setNumerableIconBackgroundIcon obj val = liftIO $ setObjectPropertyObject obj "background-icon" val++constructNumerableIconBackgroundIcon :: (Gio.IconK a) => a -> IO ([Char], GValue)+constructNumerableIconBackgroundIcon val = constructObjectPropertyObject "background-icon" val++data NumerableIconBackgroundIconPropertyInfo+instance AttrInfo NumerableIconBackgroundIconPropertyInfo where+    type AttrAllowedOps NumerableIconBackgroundIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NumerableIconBackgroundIconPropertyInfo = Gio.IconK+    type AttrBaseTypeConstraint NumerableIconBackgroundIconPropertyInfo = NumerableIconK+    type AttrGetType NumerableIconBackgroundIconPropertyInfo = Gio.Icon+    type AttrLabel NumerableIconBackgroundIconPropertyInfo = "NumerableIcon::background-icon"+    attrGet _ = getNumerableIconBackgroundIcon+    attrSet _ = setNumerableIconBackgroundIcon+    attrConstruct _ = constructNumerableIconBackgroundIcon++-- VVV Prop "background-icon-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getNumerableIconBackgroundIconName :: (MonadIO m, NumerableIconK o) => o -> m T.Text+getNumerableIconBackgroundIconName obj = liftIO $ getObjectPropertyString obj "background-icon-name"++setNumerableIconBackgroundIconName :: (MonadIO m, NumerableIconK o) => o -> T.Text -> m ()+setNumerableIconBackgroundIconName obj val = liftIO $ setObjectPropertyString obj "background-icon-name" val++constructNumerableIconBackgroundIconName :: T.Text -> IO ([Char], GValue)+constructNumerableIconBackgroundIconName val = constructObjectPropertyString "background-icon-name" val++data NumerableIconBackgroundIconNamePropertyInfo+instance AttrInfo NumerableIconBackgroundIconNamePropertyInfo where+    type AttrAllowedOps NumerableIconBackgroundIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NumerableIconBackgroundIconNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NumerableIconBackgroundIconNamePropertyInfo = NumerableIconK+    type AttrGetType NumerableIconBackgroundIconNamePropertyInfo = T.Text+    type AttrLabel NumerableIconBackgroundIconNamePropertyInfo = "NumerableIcon::background-icon-name"+    attrGet _ = getNumerableIconBackgroundIconName+    attrSet _ = setNumerableIconBackgroundIconName+    attrConstruct _ = constructNumerableIconBackgroundIconName++-- VVV Prop "count"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getNumerableIconCount :: (MonadIO m, NumerableIconK o) => o -> m Int32+getNumerableIconCount obj = liftIO $ getObjectPropertyCInt obj "count"++setNumerableIconCount :: (MonadIO m, NumerableIconK o) => o -> Int32 -> m ()+setNumerableIconCount obj val = liftIO $ setObjectPropertyCInt obj "count" val++constructNumerableIconCount :: Int32 -> IO ([Char], GValue)+constructNumerableIconCount val = constructObjectPropertyCInt "count" val++data NumerableIconCountPropertyInfo+instance AttrInfo NumerableIconCountPropertyInfo where+    type AttrAllowedOps NumerableIconCountPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NumerableIconCountPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint NumerableIconCountPropertyInfo = NumerableIconK+    type AttrGetType NumerableIconCountPropertyInfo = Int32+    type AttrLabel NumerableIconCountPropertyInfo = "NumerableIcon::count"+    attrGet _ = getNumerableIconCount+    attrSet _ = setNumerableIconCount+    attrConstruct _ = constructNumerableIconCount++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getNumerableIconLabel :: (MonadIO m, NumerableIconK o) => o -> m T.Text+getNumerableIconLabel obj = liftIO $ getObjectPropertyString obj "label"++setNumerableIconLabel :: (MonadIO m, NumerableIconK o) => o -> T.Text -> m ()+setNumerableIconLabel obj val = liftIO $ setObjectPropertyString obj "label" val++constructNumerableIconLabel :: T.Text -> IO ([Char], GValue)+constructNumerableIconLabel val = constructObjectPropertyString "label" val++data NumerableIconLabelPropertyInfo+instance AttrInfo NumerableIconLabelPropertyInfo where+    type AttrAllowedOps NumerableIconLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NumerableIconLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint NumerableIconLabelPropertyInfo = NumerableIconK+    type AttrGetType NumerableIconLabelPropertyInfo = T.Text+    type AttrLabel NumerableIconLabelPropertyInfo = "NumerableIcon::label"+    attrGet _ = getNumerableIconLabel+    attrSet _ = setNumerableIconLabel+    attrConstruct _ = constructNumerableIconLabel++-- VVV Prop "style-context"+   -- Type: TInterface "Gtk" "StyleContext"+   -- Flags: [PropertyReadable,PropertyWritable]++getNumerableIconStyleContext :: (MonadIO m, NumerableIconK o) => o -> m StyleContext+getNumerableIconStyleContext obj = liftIO $ getObjectPropertyObject obj "style-context" StyleContext++setNumerableIconStyleContext :: (MonadIO m, NumerableIconK o, StyleContextK a) => o -> a -> m ()+setNumerableIconStyleContext obj val = liftIO $ setObjectPropertyObject obj "style-context" val++constructNumerableIconStyleContext :: (StyleContextK a) => a -> IO ([Char], GValue)+constructNumerableIconStyleContext val = constructObjectPropertyObject "style-context" val++data NumerableIconStyleContextPropertyInfo+instance AttrInfo NumerableIconStyleContextPropertyInfo where+    type AttrAllowedOps NumerableIconStyleContextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint NumerableIconStyleContextPropertyInfo = StyleContextK+    type AttrBaseTypeConstraint NumerableIconStyleContextPropertyInfo = NumerableIconK+    type AttrGetType NumerableIconStyleContextPropertyInfo = StyleContext+    type AttrLabel NumerableIconStyleContextPropertyInfo = "NumerableIcon::style-context"+    attrGet _ = getNumerableIconStyleContext+    attrSet _ = setNumerableIconStyleContext+    attrConstruct _ = constructNumerableIconStyleContext++type instance AttributeList NumerableIcon = NumerableIconAttributeList+type NumerableIconAttributeList = ('[ '("background-icon", NumerableIconBackgroundIconPropertyInfo), '("background-icon-name", NumerableIconBackgroundIconNamePropertyInfo), '("count", NumerableIconCountPropertyInfo), '("gicon", Gio.EmblemedIconGiconPropertyInfo), '("label", NumerableIconLabelPropertyInfo), '("style-context", NumerableIconStyleContextPropertyInfo)] :: [(Symbol, *)])++type instance SignalList NumerableIcon = NumerableIconSignalList+type NumerableIconSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method NumerableIcon::get_background_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_get_background_gicon" gtk_numerable_icon_get_background_gicon :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    IO (Ptr Gio.Icon)++{-# DEPRECATED numerableIconGetBackgroundGicon ["(Since version 3.14)"]#-}+numerableIconGetBackgroundGicon ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    m Gio.Icon+numerableIconGetBackgroundGicon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_numerable_icon_get_background_gicon _obj'+    checkUnexpectedReturnNULL "gtk_numerable_icon_get_background_gicon" result+    result' <- (newObject Gio.Icon) result+    touchManagedPtr _obj+    return result'++-- method NumerableIcon::get_background_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_get_background_icon_name" gtk_numerable_icon_get_background_icon_name :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    IO CString++{-# DEPRECATED numerableIconGetBackgroundIconName ["(Since version 3.14)"]#-}+numerableIconGetBackgroundIconName ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    m T.Text+numerableIconGetBackgroundIconName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_numerable_icon_get_background_icon_name _obj'+    checkUnexpectedReturnNULL "gtk_numerable_icon_get_background_icon_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NumerableIcon::get_count+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_get_count" gtk_numerable_icon_get_count :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    IO Int32++{-# DEPRECATED numerableIconGetCount ["(Since version 3.14)"]#-}+numerableIconGetCount ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    m Int32+numerableIconGetCount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_numerable_icon_get_count _obj'+    touchManagedPtr _obj+    return result++-- method NumerableIcon::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_get_label" gtk_numerable_icon_get_label :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    IO CString++{-# DEPRECATED numerableIconGetLabel ["(Since version 3.14)"]#-}+numerableIconGetLabel ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    m T.Text+numerableIconGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_numerable_icon_get_label _obj'+    checkUnexpectedReturnNULL "gtk_numerable_icon_get_label" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method NumerableIcon::get_style_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "StyleContext"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_get_style_context" gtk_numerable_icon_get_style_context :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    IO (Ptr StyleContext)++{-# DEPRECATED numerableIconGetStyleContext ["(Since version 3.14)"]#-}+numerableIconGetStyleContext ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    m StyleContext+numerableIconGetStyleContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_numerable_icon_get_style_context _obj'+    checkUnexpectedReturnNULL "gtk_numerable_icon_get_style_context" result+    result' <- (newObject StyleContext) result+    touchManagedPtr _obj+    return result'++-- method NumerableIcon::set_background_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_set_background_gicon" gtk_numerable_icon_set_background_gicon :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    Ptr Gio.Icon ->                         -- icon : TInterface "Gio" "Icon"+    IO ()++{-# DEPRECATED numerableIconSetBackgroundGicon ["(Since version 3.14)"]#-}+numerableIconSetBackgroundGicon ::+    (MonadIO m, NumerableIconK a, Gio.IconK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- icon+    m ()+numerableIconSetBackgroundGicon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIcon <- case icon of+        Nothing -> return nullPtr+        Just jIcon -> do+            let jIcon' = unsafeManagedPtrCastPtr jIcon+            return jIcon'+    gtk_numerable_icon_set_background_gicon _obj' maybeIcon+    touchManagedPtr _obj+    whenJust icon touchManagedPtr+    return ()++-- method NumerableIcon::set_background_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon_name", 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 "gtk_numerable_icon_set_background_icon_name" gtk_numerable_icon_set_background_icon_name :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    CString ->                              -- icon_name : TBasicType TUTF8+    IO ()++{-# DEPRECATED numerableIconSetBackgroundIconName ["(Since version 3.14)"]#-}+numerableIconSetBackgroundIconName ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- icon_name+    m ()+numerableIconSetBackgroundIconName _obj icon_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeIcon_name <- case icon_name of+        Nothing -> return nullPtr+        Just jIcon_name -> do+            jIcon_name' <- textToCString jIcon_name+            return jIcon_name'+    gtk_numerable_icon_set_background_icon_name _obj' maybeIcon_name+    touchManagedPtr _obj+    freeMem maybeIcon_name+    return ()++-- method NumerableIcon::set_count+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "count", 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 "gtk_numerable_icon_set_count" gtk_numerable_icon_set_count :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    Int32 ->                                -- count : TBasicType TInt32+    IO ()++{-# DEPRECATED numerableIconSetCount ["(Since version 3.14)"]#-}+numerableIconSetCount ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- count+    m ()+numerableIconSetCount _obj count = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_numerable_icon_set_count _obj' count+    touchManagedPtr _obj+    return ()++-- method NumerableIcon::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", 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 "Gtk" "NumerableIcon", 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 "gtk_numerable_icon_set_label" gtk_numerable_icon_set_label :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    CString ->                              -- label : TBasicType TUTF8+    IO ()++{-# DEPRECATED numerableIconSetLabel ["(Since version 3.14)"]#-}+numerableIconSetLabel ::+    (MonadIO m, NumerableIconK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+numerableIconSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    gtk_numerable_icon_set_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method NumerableIcon::set_style_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "NumerableIcon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_set_style_context" gtk_numerable_icon_set_style_context :: +    Ptr NumerableIcon ->                    -- _obj : TInterface "Gtk" "NumerableIcon"+    Ptr StyleContext ->                     -- style : TInterface "Gtk" "StyleContext"+    IO ()++{-# DEPRECATED numerableIconSetStyleContext ["(Since version 3.14)"]#-}+numerableIconSetStyleContext ::+    (MonadIO m, NumerableIconK a, StyleContextK b) =>+    a ->                                    -- _obj+    b ->                                    -- style+    m ()+numerableIconSetStyleContext _obj style = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let style' = unsafeManagedPtrCastPtr style+    gtk_numerable_icon_set_style_context _obj' style'+    touchManagedPtr _obj+    touchManagedPtr style+    return ()++-- method NumerableIcon::new+-- method type : MemberFunction+-- Args : [Arg {argName = "base_icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_new" gtk_numerable_icon_new :: +    Ptr Gio.Icon ->                         -- base_icon : TInterface "Gio" "Icon"+    IO (Ptr Gio.Icon)++{-# DEPRECATED numerableIconNew ["(Since version 3.14)"]#-}+numerableIconNew ::+    (MonadIO m, Gio.IconK a) =>+    a ->                                    -- base_icon+    m Gio.Icon+numerableIconNew base_icon = liftIO $ do+    let base_icon' = unsafeManagedPtrCastPtr base_icon+    result <- gtk_numerable_icon_new base_icon'+    checkUnexpectedReturnNULL "gtk_numerable_icon_new" result+    result' <- (wrapObject Gio.Icon) result+    touchManagedPtr base_icon+    return result'++-- method NumerableIcon::new_with_style_context+-- method type : MemberFunction+-- Args : [Arg {argName = "base_icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "base_icon", argType = TInterface "Gio" "Icon", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gtk" "StyleContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "Icon"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_numerable_icon_new_with_style_context" gtk_numerable_icon_new_with_style_context :: +    Ptr Gio.Icon ->                         -- base_icon : TInterface "Gio" "Icon"+    Ptr StyleContext ->                     -- context : TInterface "Gtk" "StyleContext"+    IO (Ptr Gio.Icon)++{-# DEPRECATED numerableIconNewWithStyleContext ["(Since version 3.14)"]#-}+numerableIconNewWithStyleContext ::+    (MonadIO m, Gio.IconK a, StyleContextK b) =>+    a ->                                    -- base_icon+    b ->                                    -- context+    m Gio.Icon+numerableIconNewWithStyleContext base_icon context = liftIO $ do+    let base_icon' = unsafeManagedPtrCastPtr base_icon+    let context' = unsafeManagedPtrCastPtr context+    result <- gtk_numerable_icon_new_with_style_context base_icon' context'+    checkUnexpectedReturnNULL "gtk_numerable_icon_new_with_style_context" result+    result' <- (wrapObject Gio.Icon) result+    touchManagedPtr base_icon+    touchManagedPtr context+    return result'++
+ GI/Gtk/Objects/NumerableIcon.hs-boot view
@@ -0,0 +1,18 @@+module GI.Gtk.Objects.NumerableIcon where++import Prelude ()+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 NumerableIcon = NumerableIcon (ForeignPtr NumerableIcon)+instance GObject NumerableIcon where+class GObject o => NumerableIconK o+instance (GObject o, IsDescendantOf NumerableIcon o) => NumerableIconK o+data NumerableIconBackgroundIconPropertyInfo+data NumerableIconBackgroundIconNamePropertyInfo+data NumerableIconCountPropertyInfo+data NumerableIconLabelPropertyInfo+data NumerableIconStyleContextPropertyInfo
+ GI/Gtk/Objects/OffscreenWindow.hs view
@@ -0,0 +1,150 @@++{- |+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.Gtk.Objects.OffscreenWindow+    ( ++-- * Exported types+    OffscreenWindow(..)                     ,+    OffscreenWindowK                        ,+    toOffscreenWindow                       ,+    noOffscreenWindow                       ,+++ -- * Methods+-- ** offscreenWindowGetPixbuf+    offscreenWindowGetPixbuf                ,+++-- ** offscreenWindowGetSurface+    offscreenWindowGetSurface               ,+++-- ** offscreenWindowNew+    offscreenWindowNew                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.GdkPixbuf as GdkPixbuf+import qualified GI.Cairo as Cairo++newtype OffscreenWindow = OffscreenWindow (ForeignPtr OffscreenWindow)+foreign import ccall "gtk_offscreen_window_get_type"+    c_gtk_offscreen_window_get_type :: IO GType++type instance ParentTypes OffscreenWindow = OffscreenWindowParentTypes+type OffscreenWindowParentTypes = '[Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject OffscreenWindow where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_offscreen_window_get_type+    ++class GObject o => OffscreenWindowK o+instance (GObject o, IsDescendantOf OffscreenWindow o) => OffscreenWindowK o++toOffscreenWindow :: OffscreenWindowK o => o -> IO OffscreenWindow+toOffscreenWindow = unsafeCastTo OffscreenWindow++noOffscreenWindow :: Maybe OffscreenWindow+noOffscreenWindow = Nothing++type instance AttributeList OffscreenWindow = OffscreenWindowAttributeList+type OffscreenWindowAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++type instance SignalList OffscreenWindow = OffscreenWindowSignalList+type OffscreenWindowSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method OffscreenWindow::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "OffscreenWindow"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_offscreen_window_new" gtk_offscreen_window_new :: +    IO (Ptr OffscreenWindow)+++offscreenWindowNew ::+    (MonadIO m) =>+    m OffscreenWindow+offscreenWindowNew  = liftIO $ do+    result <- gtk_offscreen_window_new+    checkUnexpectedReturnNULL "gtk_offscreen_window_new" result+    result' <- (newObject OffscreenWindow) result+    return result'++-- method OffscreenWindow::get_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "OffscreenWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "OffscreenWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GdkPixbuf" "Pixbuf"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_offscreen_window_get_pixbuf" gtk_offscreen_window_get_pixbuf :: +    Ptr OffscreenWindow ->                  -- _obj : TInterface "Gtk" "OffscreenWindow"+    IO (Ptr GdkPixbuf.Pixbuf)+++offscreenWindowGetPixbuf ::+    (MonadIO m, OffscreenWindowK a) =>+    a ->                                    -- _obj+    m GdkPixbuf.Pixbuf+offscreenWindowGetPixbuf _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_offscreen_window_get_pixbuf _obj'+    checkUnexpectedReturnNULL "gtk_offscreen_window_get_pixbuf" result+    result' <- (wrapObject GdkPixbuf.Pixbuf) result+    touchManagedPtr _obj+    return result'++-- method OffscreenWindow::get_surface+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "OffscreenWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "OffscreenWindow", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_offscreen_window_get_surface" gtk_offscreen_window_get_surface :: +    Ptr OffscreenWindow ->                  -- _obj : TInterface "Gtk" "OffscreenWindow"+    IO (Ptr Cairo.Surface)+++offscreenWindowGetSurface ::+    (MonadIO m, OffscreenWindowK a) =>+    a ->                                    -- _obj+    m Cairo.Surface+offscreenWindowGetSurface _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_offscreen_window_get_surface _obj'+    checkUnexpectedReturnNULL "gtk_offscreen_window_get_surface" result+    result' <- (newBoxed Cairo.Surface) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/OffscreenWindow.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.OffscreenWindow where++import Prelude ()+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 OffscreenWindow = OffscreenWindow (ForeignPtr OffscreenWindow)+instance GObject OffscreenWindow where+class GObject o => OffscreenWindowK o+instance (GObject o, IsDescendantOf OffscreenWindow o) => OffscreenWindowK o
+ GI/Gtk/Objects/Overlay.hs view
@@ -0,0 +1,222 @@++{- |+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.Gtk.Objects.Overlay+    ( ++-- * Exported types+    Overlay(..)                             ,+    OverlayK                                ,+    toOverlay                               ,+    noOverlay                               ,+++ -- * Methods+-- ** overlayAddOverlay+    overlayAddOverlay                       ,+++-- ** overlayGetOverlayPassThrough+    overlayGetOverlayPassThrough            ,+++-- ** overlayNew+    overlayNew                              ,+++-- ** overlayReorderOverlay+    overlayReorderOverlay                   ,+++-- ** overlaySetOverlayPassThrough+    overlaySetOverlayPassThrough            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype Overlay = Overlay (ForeignPtr Overlay)+foreign import ccall "gtk_overlay_get_type"+    c_gtk_overlay_get_type :: IO GType++type instance ParentTypes Overlay = OverlayParentTypes+type OverlayParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Overlay where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_overlay_get_type+    ++class GObject o => OverlayK o+instance (GObject o, IsDescendantOf Overlay o) => OverlayK o++toOverlay :: OverlayK o => o -> IO Overlay+toOverlay = unsafeCastTo Overlay++noOverlay :: Maybe Overlay+noOverlay = Nothing++type instance AttributeList Overlay = OverlayAttributeList+type OverlayAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Overlay = OverlaySignalList+type OverlaySignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Overlay::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "Overlay"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_overlay_new" gtk_overlay_new :: +    IO (Ptr Overlay)+++overlayNew ::+    (MonadIO m) =>+    m Overlay+overlayNew  = liftIO $ do+    result <- gtk_overlay_new+    checkUnexpectedReturnNULL "gtk_overlay_new" result+    result' <- (newObject Overlay) result+    return result'++-- method Overlay::add_overlay+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_overlay_add_overlay" gtk_overlay_add_overlay :: +    Ptr Overlay ->                          -- _obj : TInterface "Gtk" "Overlay"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++overlayAddOverlay ::+    (MonadIO m, OverlayK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m ()+overlayAddOverlay _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    gtk_overlay_add_overlay _obj' widget'+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++-- method Overlay::get_overlay_pass_through+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_overlay_get_overlay_pass_through" gtk_overlay_get_overlay_pass_through :: +    Ptr Overlay ->                          -- _obj : TInterface "Gtk" "Overlay"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO CInt+++overlayGetOverlayPassThrough ::+    (MonadIO m, OverlayK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    m Bool+overlayGetOverlayPassThrough _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    result <- gtk_overlay_get_overlay_pass_through _obj' widget'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr widget+    return result'++-- method Overlay::reorder_overlay+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", 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 "gtk_overlay_reorder_overlay" gtk_overlay_reorder_overlay :: +    Ptr Overlay ->                          -- _obj : TInterface "Gtk" "Overlay"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++overlayReorderOverlay ::+    (MonadIO m, OverlayK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Int32 ->                                -- position+    m ()+overlayReorderOverlay _obj child position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_overlay_reorder_overlay _obj' child' position+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Overlay::set_overlay_pass_through+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pass_through", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Overlay", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pass_through", 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 "gtk_overlay_set_overlay_pass_through" gtk_overlay_set_overlay_pass_through :: +    Ptr Overlay ->                          -- _obj : TInterface "Gtk" "Overlay"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    CInt ->                                 -- pass_through : TBasicType TBoolean+    IO ()+++overlaySetOverlayPassThrough ::+    (MonadIO m, OverlayK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- widget+    Bool ->                                 -- pass_through+    m ()+overlaySetOverlayPassThrough _obj widget pass_through = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let widget' = unsafeManagedPtrCastPtr widget+    let pass_through' = (fromIntegral . fromEnum) pass_through+    gtk_overlay_set_overlay_pass_through _obj' widget' pass_through'+    touchManagedPtr _obj+    touchManagedPtr widget+    return ()++
+ GI/Gtk/Objects/Overlay.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.Overlay where++import Prelude ()+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 Overlay = Overlay (ForeignPtr Overlay)+instance GObject Overlay where+class GObject o => OverlayK o+instance (GObject o, IsDescendantOf Overlay o) => OverlayK o
+ GI/Gtk/Objects/PageSetup.hs view
@@ -0,0 +1,897 @@++{- |+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.Gtk.Objects.PageSetup+    ( ++-- * Exported types+    PageSetup(..)                           ,+    PageSetupK                              ,+    toPageSetup                             ,+    noPageSetup                             ,+++ -- * Methods+-- ** pageSetupCopy+    pageSetupCopy                           ,+++-- ** pageSetupGetBottomMargin+    pageSetupGetBottomMargin                ,+++-- ** pageSetupGetLeftMargin+    pageSetupGetLeftMargin                  ,+++-- ** pageSetupGetOrientation+    pageSetupGetOrientation                 ,+++-- ** pageSetupGetPageHeight+    pageSetupGetPageHeight                  ,+++-- ** pageSetupGetPageWidth+    pageSetupGetPageWidth                   ,+++-- ** pageSetupGetPaperHeight+    pageSetupGetPaperHeight                 ,+++-- ** pageSetupGetPaperSize+    pageSetupGetPaperSize                   ,+++-- ** pageSetupGetPaperWidth+    pageSetupGetPaperWidth                  ,+++-- ** pageSetupGetRightMargin+    pageSetupGetRightMargin                 ,+++-- ** pageSetupGetTopMargin+    pageSetupGetTopMargin                   ,+++-- ** pageSetupLoadFile+    pageSetupLoadFile                       ,+++-- ** pageSetupLoadKeyFile+    pageSetupLoadKeyFile                    ,+++-- ** pageSetupNew+    pageSetupNew                            ,+++-- ** pageSetupNewFromFile+    pageSetupNewFromFile                    ,+++-- ** pageSetupNewFromKeyFile+    pageSetupNewFromKeyFile                 ,+++-- ** pageSetupSetBottomMargin+    pageSetupSetBottomMargin                ,+++-- ** pageSetupSetLeftMargin+    pageSetupSetLeftMargin                  ,+++-- ** pageSetupSetOrientation+    pageSetupSetOrientation                 ,+++-- ** pageSetupSetPaperSize+    pageSetupSetPaperSize                   ,+++-- ** pageSetupSetPaperSizeAndDefaultMargins+    pageSetupSetPaperSizeAndDefaultMargins  ,+++-- ** pageSetupSetRightMargin+    pageSetupSetRightMargin                 ,+++-- ** pageSetupSetTopMargin+    pageSetupSetTopMargin                   ,+++-- ** pageSetupToFile+    pageSetupToFile                         ,+++-- ** pageSetupToKeyFile+    pageSetupToKeyFile                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype PageSetup = PageSetup (ForeignPtr PageSetup)+foreign import ccall "gtk_page_setup_get_type"+    c_gtk_page_setup_get_type :: IO GType++type instance ParentTypes PageSetup = PageSetupParentTypes+type PageSetupParentTypes = '[GObject.Object]++instance GObject PageSetup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_page_setup_get_type+    ++class GObject o => PageSetupK o+instance (GObject o, IsDescendantOf PageSetup o) => PageSetupK o++toPageSetup :: PageSetupK o => o -> IO PageSetup+toPageSetup = unsafeCastTo PageSetup++noPageSetup :: Maybe PageSetup+noPageSetup = Nothing++type instance AttributeList PageSetup = PageSetupAttributeList+type PageSetupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PageSetup = PageSetupSignalList+type PageSetupSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PageSetup::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_new" gtk_page_setup_new :: +    IO (Ptr PageSetup)+++pageSetupNew ::+    (MonadIO m) =>+    m PageSetup+pageSetupNew  = liftIO $ do+    result <- gtk_page_setup_new+    checkUnexpectedReturnNULL "gtk_page_setup_new" result+    result' <- (wrapObject PageSetup) result+    return result'++-- method PageSetup::new_from_file+-- method type : Constructor+-- Args : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_page_setup_new_from_file" gtk_page_setup_new_from_file :: +    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PageSetup)+++pageSetupNewFromFile ::+    (MonadIO m) =>+    [Char] ->                               -- file_name+    m PageSetup+pageSetupNewFromFile file_name = liftIO $ do+    file_name' <- stringToCString file_name+    onException (do+        result <- propagateGError $ gtk_page_setup_new_from_file file_name'+        checkUnexpectedReturnNULL "gtk_page_setup_new_from_file" result+        result' <- (wrapObject PageSetup) result+        freeMem file_name'+        return result'+     ) (do+        freeMem file_name'+     )++-- method PageSetup::new_from_key_file+-- method type : Constructor+-- Args : [Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_page_setup_new_from_key_file" gtk_page_setup_new_from_key_file :: +    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PageSetup)+++pageSetupNewFromKeyFile ::+    (MonadIO m) =>+    GLib.KeyFile ->                         -- key_file+    Maybe (T.Text) ->                       -- group_name+    m PageSetup+pageSetupNewFromKeyFile key_file group_name = liftIO $ do+    let key_file' = unsafeManagedPtrGetPtr key_file+    maybeGroup_name <- case group_name of+        Nothing -> return nullPtr+        Just jGroup_name -> do+            jGroup_name' <- textToCString jGroup_name+            return jGroup_name'+    onException (do+        result <- propagateGError $ gtk_page_setup_new_from_key_file key_file' maybeGroup_name+        checkUnexpectedReturnNULL "gtk_page_setup_new_from_key_file" result+        result' <- (wrapObject PageSetup) result+        touchManagedPtr key_file+        freeMem maybeGroup_name+        return result'+     ) (do+        freeMem maybeGroup_name+     )++-- method PageSetup::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_copy" gtk_page_setup_copy :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    IO (Ptr PageSetup)+++pageSetupCopy ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    m PageSetup+pageSetupCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_page_setup_copy _obj'+    checkUnexpectedReturnNULL "gtk_page_setup_copy" result+    result' <- (wrapObject PageSetup) result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_bottom_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_bottom_margin" gtk_page_setup_get_bottom_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetBottomMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetBottomMargin _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_bottom_margin _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_left_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_left_margin" gtk_page_setup_get_left_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetLeftMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetLeftMargin _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_left_margin _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageOrientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_orientation" gtk_page_setup_get_orientation :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    IO CUInt+++pageSetupGetOrientation ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    m PageOrientation+pageSetupGetOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_page_setup_get_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_page_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_page_height" gtk_page_setup_get_page_height :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetPageHeight ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetPageHeight _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_page_height _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_page_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_page_width" gtk_page_setup_get_page_width :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetPageWidth ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetPageWidth _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_page_width _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_paper_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_paper_height" gtk_page_setup_get_paper_height :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetPaperHeight ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetPaperHeight _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_paper_height _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_paper_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PaperSize"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_paper_size" gtk_page_setup_get_paper_size :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    IO (Ptr PaperSize)+++pageSetupGetPaperSize ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    m PaperSize+pageSetupGetPaperSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_page_setup_get_paper_size _obj'+    checkUnexpectedReturnNULL "gtk_page_setup_get_paper_size" result+    result' <- (newBoxed PaperSize) result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_paper_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_paper_width" gtk_page_setup_get_paper_width :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetPaperWidth ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetPaperWidth _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_paper_width _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_right_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_right_margin" gtk_page_setup_get_right_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetRightMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetRightMargin _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_right_margin _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::get_top_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_get_top_margin" gtk_page_setup_get_top_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++pageSetupGetTopMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+pageSetupGetTopMargin _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_page_setup_get_top_margin _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PageSetup::load_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_page_setup_load_file" gtk_page_setup_load_file :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++pageSetupLoadFile ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- file_name+    m ()+pageSetupLoadFile _obj file_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    file_name' <- stringToCString file_name+    onException (do+        _ <- propagateGError $ gtk_page_setup_load_file _obj' file_name'+        touchManagedPtr _obj+        freeMem file_name'+        return ()+     ) (do+        freeMem file_name'+     )++-- method PageSetup::load_key_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", 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 "gtk_page_setup_load_key_file" gtk_page_setup_load_key_file :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++pageSetupLoadKeyFile ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    GLib.KeyFile ->                         -- key_file+    Maybe (T.Text) ->                       -- group_name+    m ()+pageSetupLoadKeyFile _obj key_file group_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let key_file' = unsafeManagedPtrGetPtr key_file+    maybeGroup_name <- case group_name of+        Nothing -> return nullPtr+        Just jGroup_name -> do+            jGroup_name' <- textToCString jGroup_name+            return jGroup_name'+    onException (do+        _ <- propagateGError $ gtk_page_setup_load_key_file _obj' key_file' maybeGroup_name+        touchManagedPtr _obj+        touchManagedPtr key_file+        freeMem maybeGroup_name+        return ()+     ) (do+        freeMem maybeGroup_name+     )++-- method PageSetup::set_bottom_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_bottom_margin" gtk_page_setup_set_bottom_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CDouble ->                              -- margin : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++pageSetupSetBottomMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Double ->                               -- margin+    Unit ->                                 -- unit+    m ()+pageSetupSetBottomMargin _obj margin unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let margin' = realToFrac margin+    let unit' = (fromIntegral . fromEnum) unit+    gtk_page_setup_set_bottom_margin _obj' margin' unit'+    touchManagedPtr _obj+    return ()++-- method PageSetup::set_left_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_left_margin" gtk_page_setup_set_left_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CDouble ->                              -- margin : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++pageSetupSetLeftMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Double ->                               -- margin+    Unit ->                                 -- unit+    m ()+pageSetupSetLeftMargin _obj margin unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let margin' = realToFrac margin+    let unit' = (fromIntegral . fromEnum) unit+    gtk_page_setup_set_left_margin _obj' margin' unit'+    touchManagedPtr _obj+    return ()++-- method PageSetup::set_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "PageOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "PageOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_orientation" gtk_page_setup_set_orientation :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CUInt ->                                -- orientation : TInterface "Gtk" "PageOrientation"+    IO ()+++pageSetupSetOrientation ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    PageOrientation ->                      -- orientation+    m ()+pageSetupSetOrientation _obj orientation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_page_setup_set_orientation _obj' orientation'+    touchManagedPtr _obj+    return ()++-- method PageSetup::set_paper_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_paper_size" gtk_page_setup_set_paper_size :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    Ptr PaperSize ->                        -- size : TInterface "Gtk" "PaperSize"+    IO ()+++pageSetupSetPaperSize ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    PaperSize ->                            -- size+    m ()+pageSetupSetPaperSize _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let size' = unsafeManagedPtrGetPtr size+    gtk_page_setup_set_paper_size _obj' size'+    touchManagedPtr _obj+    touchManagedPtr size+    return ()++-- method PageSetup::set_paper_size_and_default_margins+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_paper_size_and_default_margins" gtk_page_setup_set_paper_size_and_default_margins :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    Ptr PaperSize ->                        -- size : TInterface "Gtk" "PaperSize"+    IO ()+++pageSetupSetPaperSizeAndDefaultMargins ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    PaperSize ->                            -- size+    m ()+pageSetupSetPaperSizeAndDefaultMargins _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let size' = unsafeManagedPtrGetPtr size+    gtk_page_setup_set_paper_size_and_default_margins _obj' size'+    touchManagedPtr _obj+    touchManagedPtr size+    return ()++-- method PageSetup::set_right_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_right_margin" gtk_page_setup_set_right_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CDouble ->                              -- margin : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++pageSetupSetRightMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Double ->                               -- margin+    Unit ->                                 -- unit+    m ()+pageSetupSetRightMargin _obj margin unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let margin' = realToFrac margin+    let unit' = (fromIntegral . fromEnum) unit+    gtk_page_setup_set_right_margin _obj' margin' unit'+    touchManagedPtr _obj+    return ()++-- method PageSetup::set_top_margin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_page_setup_set_top_margin" gtk_page_setup_set_top_margin :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CDouble ->                              -- margin : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++pageSetupSetTopMargin ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    Double ->                               -- margin+    Unit ->                                 -- unit+    m ()+pageSetupSetTopMargin _obj margin unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let margin' = realToFrac margin+    let unit' = (fromIntegral . fromEnum) unit+    gtk_page_setup_set_top_margin _obj' margin' unit'+    touchManagedPtr _obj+    return ()++-- method PageSetup::to_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_page_setup_to_file" gtk_page_setup_to_file :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++pageSetupToFile ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- file_name+    m ()+pageSetupToFile _obj file_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    file_name' <- stringToCString file_name+    onException (do+        _ <- propagateGError $ gtk_page_setup_to_file _obj' file_name'+        touchManagedPtr _obj+        freeMem file_name'+        return ()+     ) (do+        freeMem file_name'+     )++-- method PageSetup::to_key_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_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 "gtk_page_setup_to_key_file" gtk_page_setup_to_key_file :: +    Ptr PageSetup ->                        -- _obj : TInterface "Gtk" "PageSetup"+    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    IO ()+++pageSetupToKeyFile ::+    (MonadIO m, PageSetupK a) =>+    a ->                                    -- _obj+    GLib.KeyFile ->                         -- key_file+    T.Text ->                               -- group_name+    m ()+pageSetupToKeyFile _obj key_file group_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let key_file' = unsafeManagedPtrGetPtr key_file+    group_name' <- textToCString group_name+    gtk_page_setup_to_key_file _obj' key_file' group_name'+    touchManagedPtr _obj+    touchManagedPtr key_file+    freeMem group_name'+    return ()++
+ GI/Gtk/Objects/PageSetup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.PageSetup where++import Prelude ()+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 PageSetup = PageSetup (ForeignPtr PageSetup)+instance GObject PageSetup where+class GObject o => PageSetupK o+instance (GObject o, IsDescendantOf PageSetup o) => PageSetupK o
+ GI/Gtk/Objects/Paned.hs view
@@ -0,0 +1,939 @@++{- |+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.Gtk.Objects.Paned+    ( ++-- * Exported types+    Paned(..)                               ,+    PanedK                                  ,+    toPaned                                 ,+    noPaned                                 ,+++ -- * Methods+-- ** panedAdd1+    panedAdd1                               ,+++-- ** panedAdd2+    panedAdd2                               ,+++-- ** panedGetChild1+    panedGetChild1                          ,+++-- ** panedGetChild2+    panedGetChild2                          ,+++-- ** panedGetHandleWindow+    panedGetHandleWindow                    ,+++-- ** panedGetPosition+    panedGetPosition                        ,+++-- ** panedGetWideHandle+    panedGetWideHandle                      ,+++-- ** panedNew+    panedNew                                ,+++-- ** panedPack1+    panedPack1                              ,+++-- ** panedPack2+    panedPack2                              ,+++-- ** panedSetPosition+    panedSetPosition                        ,+++-- ** panedSetWideHandle+    panedSetWideHandle                      ,+++++ -- * Properties+-- ** MaxPosition+    PanedMaxPositionPropertyInfo            ,+    getPanedMaxPosition                     ,+++-- ** MinPosition+    PanedMinPositionPropertyInfo            ,+    getPanedMinPosition                     ,+++-- ** Position+    PanedPositionPropertyInfo               ,+    constructPanedPosition                  ,+    getPanedPosition                        ,+    setPanedPosition                        ,+++-- ** PositionSet+    PanedPositionSetPropertyInfo            ,+    constructPanedPositionSet               ,+    getPanedPositionSet                     ,+    setPanedPositionSet                     ,+++-- ** WideHandle+    PanedWideHandlePropertyInfo             ,+    constructPanedWideHandle                ,+    getPanedWideHandle                      ,+    setPanedWideHandle                      ,+++++ -- * Signals+-- ** AcceptPosition+    PanedAcceptPositionCallback             ,+    PanedAcceptPositionCallbackC            ,+    PanedAcceptPositionSignalInfo           ,+    afterPanedAcceptPosition                ,+    mkPanedAcceptPositionCallback           ,+    noPanedAcceptPositionCallback           ,+    onPanedAcceptPosition                   ,+    panedAcceptPositionCallbackWrapper      ,+    panedAcceptPositionClosure              ,+++-- ** CancelPosition+    PanedCancelPositionCallback             ,+    PanedCancelPositionCallbackC            ,+    PanedCancelPositionSignalInfo           ,+    afterPanedCancelPosition                ,+    mkPanedCancelPositionCallback           ,+    noPanedCancelPositionCallback           ,+    onPanedCancelPosition                   ,+    panedCancelPositionCallbackWrapper      ,+    panedCancelPositionClosure              ,+++-- ** CycleChildFocus+    PanedCycleChildFocusCallback            ,+    PanedCycleChildFocusCallbackC           ,+    PanedCycleChildFocusSignalInfo          ,+    afterPanedCycleChildFocus               ,+    mkPanedCycleChildFocusCallback          ,+    noPanedCycleChildFocusCallback          ,+    onPanedCycleChildFocus                  ,+    panedCycleChildFocusCallbackWrapper     ,+    panedCycleChildFocusClosure             ,+++-- ** CycleHandleFocus+    PanedCycleHandleFocusCallback           ,+    PanedCycleHandleFocusCallbackC          ,+    PanedCycleHandleFocusSignalInfo         ,+    afterPanedCycleHandleFocus              ,+    mkPanedCycleHandleFocusCallback         ,+    noPanedCycleHandleFocusCallback         ,+    onPanedCycleHandleFocus                 ,+    panedCycleHandleFocusCallbackWrapper    ,+    panedCycleHandleFocusClosure            ,+++-- ** MoveHandle+    PanedMoveHandleCallback                 ,+    PanedMoveHandleCallbackC                ,+    PanedMoveHandleSignalInfo               ,+    afterPanedMoveHandle                    ,+    mkPanedMoveHandleCallback               ,+    noPanedMoveHandleCallback               ,+    onPanedMoveHandle                       ,+    panedMoveHandleCallbackWrapper          ,+    panedMoveHandleClosure                  ,+++-- ** ToggleHandleFocus+    PanedToggleHandleFocusCallback          ,+    PanedToggleHandleFocusCallbackC         ,+    PanedToggleHandleFocusSignalInfo        ,+    afterPanedToggleHandleFocus             ,+    mkPanedToggleHandleFocusCallback        ,+    noPanedToggleHandleFocusCallback        ,+    onPanedToggleHandleFocus                ,+    panedToggleHandleFocusCallbackWrapper   ,+    panedToggleHandleFocusClosure           ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Paned = Paned (ForeignPtr Paned)+foreign import ccall "gtk_paned_get_type"+    c_gtk_paned_get_type :: IO GType++type instance ParentTypes Paned = PanedParentTypes+type PanedParentTypes = '[Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject Paned where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_paned_get_type+    ++class GObject o => PanedK o+instance (GObject o, IsDescendantOf Paned o) => PanedK o++toPaned :: PanedK o => o -> IO Paned+toPaned = unsafeCastTo Paned++noPaned :: Maybe Paned+noPaned = Nothing++-- signal Paned::accept-position+type PanedAcceptPositionCallback =+    IO Bool++noPanedAcceptPositionCallback :: Maybe PanedAcceptPositionCallback+noPanedAcceptPositionCallback = Nothing++type PanedAcceptPositionCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedAcceptPositionCallback :: PanedAcceptPositionCallbackC -> IO (FunPtr PanedAcceptPositionCallbackC)++panedAcceptPositionClosure :: PanedAcceptPositionCallback -> IO Closure+panedAcceptPositionClosure cb = newCClosure =<< mkPanedAcceptPositionCallback wrapped+    where wrapped = panedAcceptPositionCallbackWrapper cb++panedAcceptPositionCallbackWrapper ::+    PanedAcceptPositionCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+panedAcceptPositionCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedAcceptPosition :: (GObject a, MonadIO m) => a -> PanedAcceptPositionCallback -> m SignalHandlerId+onPanedAcceptPosition obj cb = liftIO $ connectPanedAcceptPosition obj cb SignalConnectBefore+afterPanedAcceptPosition :: (GObject a, MonadIO m) => a -> PanedAcceptPositionCallback -> m SignalHandlerId+afterPanedAcceptPosition obj cb = connectPanedAcceptPosition obj cb SignalConnectAfter++connectPanedAcceptPosition :: (GObject a, MonadIO m) =>+                              a -> PanedAcceptPositionCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedAcceptPosition obj cb after = liftIO $ do+    cb' <- mkPanedAcceptPositionCallback (panedAcceptPositionCallbackWrapper cb)+    connectSignalFunPtr obj "accept-position" cb' after++-- signal Paned::cancel-position+type PanedCancelPositionCallback =+    IO Bool++noPanedCancelPositionCallback :: Maybe PanedCancelPositionCallback+noPanedCancelPositionCallback = Nothing++type PanedCancelPositionCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedCancelPositionCallback :: PanedCancelPositionCallbackC -> IO (FunPtr PanedCancelPositionCallbackC)++panedCancelPositionClosure :: PanedCancelPositionCallback -> IO Closure+panedCancelPositionClosure cb = newCClosure =<< mkPanedCancelPositionCallback wrapped+    where wrapped = panedCancelPositionCallbackWrapper cb++panedCancelPositionCallbackWrapper ::+    PanedCancelPositionCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+panedCancelPositionCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedCancelPosition :: (GObject a, MonadIO m) => a -> PanedCancelPositionCallback -> m SignalHandlerId+onPanedCancelPosition obj cb = liftIO $ connectPanedCancelPosition obj cb SignalConnectBefore+afterPanedCancelPosition :: (GObject a, MonadIO m) => a -> PanedCancelPositionCallback -> m SignalHandlerId+afterPanedCancelPosition obj cb = connectPanedCancelPosition obj cb SignalConnectAfter++connectPanedCancelPosition :: (GObject a, MonadIO m) =>+                              a -> PanedCancelPositionCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedCancelPosition obj cb after = liftIO $ do+    cb' <- mkPanedCancelPositionCallback (panedCancelPositionCallbackWrapper cb)+    connectSignalFunPtr obj "cancel-position" cb' after++-- signal Paned::cycle-child-focus+type PanedCycleChildFocusCallback =+    Bool ->+    IO Bool++noPanedCycleChildFocusCallback :: Maybe PanedCycleChildFocusCallback+noPanedCycleChildFocusCallback = Nothing++type PanedCycleChildFocusCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedCycleChildFocusCallback :: PanedCycleChildFocusCallbackC -> IO (FunPtr PanedCycleChildFocusCallbackC)++panedCycleChildFocusClosure :: PanedCycleChildFocusCallback -> IO Closure+panedCycleChildFocusClosure cb = newCClosure =<< mkPanedCycleChildFocusCallback wrapped+    where wrapped = panedCycleChildFocusCallbackWrapper cb++panedCycleChildFocusCallbackWrapper ::+    PanedCycleChildFocusCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO CInt+panedCycleChildFocusCallbackWrapper _cb _ reversed _ = do+    let reversed' = (/= 0) reversed+    result <- _cb  reversed'+    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedCycleChildFocus :: (GObject a, MonadIO m) => a -> PanedCycleChildFocusCallback -> m SignalHandlerId+onPanedCycleChildFocus obj cb = liftIO $ connectPanedCycleChildFocus obj cb SignalConnectBefore+afterPanedCycleChildFocus :: (GObject a, MonadIO m) => a -> PanedCycleChildFocusCallback -> m SignalHandlerId+afterPanedCycleChildFocus obj cb = connectPanedCycleChildFocus obj cb SignalConnectAfter++connectPanedCycleChildFocus :: (GObject a, MonadIO m) =>+                               a -> PanedCycleChildFocusCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedCycleChildFocus obj cb after = liftIO $ do+    cb' <- mkPanedCycleChildFocusCallback (panedCycleChildFocusCallbackWrapper cb)+    connectSignalFunPtr obj "cycle-child-focus" cb' after++-- signal Paned::cycle-handle-focus+type PanedCycleHandleFocusCallback =+    Bool ->+    IO Bool++noPanedCycleHandleFocusCallback :: Maybe PanedCycleHandleFocusCallback+noPanedCycleHandleFocusCallback = Nothing++type PanedCycleHandleFocusCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedCycleHandleFocusCallback :: PanedCycleHandleFocusCallbackC -> IO (FunPtr PanedCycleHandleFocusCallbackC)++panedCycleHandleFocusClosure :: PanedCycleHandleFocusCallback -> IO Closure+panedCycleHandleFocusClosure cb = newCClosure =<< mkPanedCycleHandleFocusCallback wrapped+    where wrapped = panedCycleHandleFocusCallbackWrapper cb++panedCycleHandleFocusCallbackWrapper ::+    PanedCycleHandleFocusCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO CInt+panedCycleHandleFocusCallbackWrapper _cb _ reversed _ = do+    let reversed' = (/= 0) reversed+    result <- _cb  reversed'+    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedCycleHandleFocus :: (GObject a, MonadIO m) => a -> PanedCycleHandleFocusCallback -> m SignalHandlerId+onPanedCycleHandleFocus obj cb = liftIO $ connectPanedCycleHandleFocus obj cb SignalConnectBefore+afterPanedCycleHandleFocus :: (GObject a, MonadIO m) => a -> PanedCycleHandleFocusCallback -> m SignalHandlerId+afterPanedCycleHandleFocus obj cb = connectPanedCycleHandleFocus obj cb SignalConnectAfter++connectPanedCycleHandleFocus :: (GObject a, MonadIO m) =>+                                a -> PanedCycleHandleFocusCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedCycleHandleFocus obj cb after = liftIO $ do+    cb' <- mkPanedCycleHandleFocusCallback (panedCycleHandleFocusCallbackWrapper cb)+    connectSignalFunPtr obj "cycle-handle-focus" cb' after++-- signal Paned::move-handle+type PanedMoveHandleCallback =+    ScrollType ->+    IO Bool++noPanedMoveHandleCallback :: Maybe PanedMoveHandleCallback+noPanedMoveHandleCallback = Nothing++type PanedMoveHandleCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedMoveHandleCallback :: PanedMoveHandleCallbackC -> IO (FunPtr PanedMoveHandleCallbackC)++panedMoveHandleClosure :: PanedMoveHandleCallback -> IO Closure+panedMoveHandleClosure cb = newCClosure =<< mkPanedMoveHandleCallback wrapped+    where wrapped = panedMoveHandleCallbackWrapper cb++panedMoveHandleCallbackWrapper ::+    PanedMoveHandleCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO CInt+panedMoveHandleCallbackWrapper _cb _ scroll_type _ = do+    let scroll_type' = (toEnum . fromIntegral) scroll_type+    result <- _cb  scroll_type'+    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedMoveHandle :: (GObject a, MonadIO m) => a -> PanedMoveHandleCallback -> m SignalHandlerId+onPanedMoveHandle obj cb = liftIO $ connectPanedMoveHandle obj cb SignalConnectBefore+afterPanedMoveHandle :: (GObject a, MonadIO m) => a -> PanedMoveHandleCallback -> m SignalHandlerId+afterPanedMoveHandle obj cb = connectPanedMoveHandle obj cb SignalConnectAfter++connectPanedMoveHandle :: (GObject a, MonadIO m) =>+                          a -> PanedMoveHandleCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedMoveHandle obj cb after = liftIO $ do+    cb' <- mkPanedMoveHandleCallback (panedMoveHandleCallbackWrapper cb)+    connectSignalFunPtr obj "move-handle" cb' after++-- signal Paned::toggle-handle-focus+type PanedToggleHandleFocusCallback =+    IO Bool++noPanedToggleHandleFocusCallback :: Maybe PanedToggleHandleFocusCallback+noPanedToggleHandleFocusCallback = Nothing++type PanedToggleHandleFocusCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPanedToggleHandleFocusCallback :: PanedToggleHandleFocusCallbackC -> IO (FunPtr PanedToggleHandleFocusCallbackC)++panedToggleHandleFocusClosure :: PanedToggleHandleFocusCallback -> IO Closure+panedToggleHandleFocusClosure cb = newCClosure =<< mkPanedToggleHandleFocusCallback wrapped+    where wrapped = panedToggleHandleFocusCallbackWrapper cb++panedToggleHandleFocusCallbackWrapper ::+    PanedToggleHandleFocusCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+panedToggleHandleFocusCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onPanedToggleHandleFocus :: (GObject a, MonadIO m) => a -> PanedToggleHandleFocusCallback -> m SignalHandlerId+onPanedToggleHandleFocus obj cb = liftIO $ connectPanedToggleHandleFocus obj cb SignalConnectBefore+afterPanedToggleHandleFocus :: (GObject a, MonadIO m) => a -> PanedToggleHandleFocusCallback -> m SignalHandlerId+afterPanedToggleHandleFocus obj cb = connectPanedToggleHandleFocus obj cb SignalConnectAfter++connectPanedToggleHandleFocus :: (GObject a, MonadIO m) =>+                                 a -> PanedToggleHandleFocusCallback -> SignalConnectMode -> m SignalHandlerId+connectPanedToggleHandleFocus obj cb after = liftIO $ do+    cb' <- mkPanedToggleHandleFocusCallback (panedToggleHandleFocusCallbackWrapper cb)+    connectSignalFunPtr obj "toggle-handle-focus" cb' after++-- VVV Prop "max-position"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getPanedMaxPosition :: (MonadIO m, PanedK o) => o -> m Int32+getPanedMaxPosition obj = liftIO $ getObjectPropertyCInt obj "max-position"++data PanedMaxPositionPropertyInfo+instance AttrInfo PanedMaxPositionPropertyInfo where+    type AttrAllowedOps PanedMaxPositionPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PanedMaxPositionPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PanedMaxPositionPropertyInfo = PanedK+    type AttrGetType PanedMaxPositionPropertyInfo = Int32+    type AttrLabel PanedMaxPositionPropertyInfo = "Paned::max-position"+    attrGet _ = getPanedMaxPosition+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "min-position"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getPanedMinPosition :: (MonadIO m, PanedK o) => o -> m Int32+getPanedMinPosition obj = liftIO $ getObjectPropertyCInt obj "min-position"++data PanedMinPositionPropertyInfo+instance AttrInfo PanedMinPositionPropertyInfo where+    type AttrAllowedOps PanedMinPositionPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PanedMinPositionPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PanedMinPositionPropertyInfo = PanedK+    type AttrGetType PanedMinPositionPropertyInfo = Int32+    type AttrLabel PanedMinPositionPropertyInfo = "Paned::min-position"+    attrGet _ = getPanedMinPosition+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "position"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getPanedPosition :: (MonadIO m, PanedK o) => o -> m Int32+getPanedPosition obj = liftIO $ getObjectPropertyCInt obj "position"++setPanedPosition :: (MonadIO m, PanedK o) => o -> Int32 -> m ()+setPanedPosition obj val = liftIO $ setObjectPropertyCInt obj "position" val++constructPanedPosition :: Int32 -> IO ([Char], GValue)+constructPanedPosition val = constructObjectPropertyCInt "position" val++data PanedPositionPropertyInfo+instance AttrInfo PanedPositionPropertyInfo where+    type AttrAllowedOps PanedPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PanedPositionPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PanedPositionPropertyInfo = PanedK+    type AttrGetType PanedPositionPropertyInfo = Int32+    type AttrLabel PanedPositionPropertyInfo = "Paned::position"+    attrGet _ = getPanedPosition+    attrSet _ = setPanedPosition+    attrConstruct _ = constructPanedPosition++-- VVV Prop "position-set"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPanedPositionSet :: (MonadIO m, PanedK o) => o -> m Bool+getPanedPositionSet obj = liftIO $ getObjectPropertyBool obj "position-set"++setPanedPositionSet :: (MonadIO m, PanedK o) => o -> Bool -> m ()+setPanedPositionSet obj val = liftIO $ setObjectPropertyBool obj "position-set" val++constructPanedPositionSet :: Bool -> IO ([Char], GValue)+constructPanedPositionSet val = constructObjectPropertyBool "position-set" val++data PanedPositionSetPropertyInfo+instance AttrInfo PanedPositionSetPropertyInfo where+    type AttrAllowedOps PanedPositionSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PanedPositionSetPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PanedPositionSetPropertyInfo = PanedK+    type AttrGetType PanedPositionSetPropertyInfo = Bool+    type AttrLabel PanedPositionSetPropertyInfo = "Paned::position-set"+    attrGet _ = getPanedPositionSet+    attrSet _ = setPanedPositionSet+    attrConstruct _ = constructPanedPositionSet++-- VVV Prop "wide-handle"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPanedWideHandle :: (MonadIO m, PanedK o) => o -> m Bool+getPanedWideHandle obj = liftIO $ getObjectPropertyBool obj "wide-handle"++setPanedWideHandle :: (MonadIO m, PanedK o) => o -> Bool -> m ()+setPanedWideHandle obj val = liftIO $ setObjectPropertyBool obj "wide-handle" val++constructPanedWideHandle :: Bool -> IO ([Char], GValue)+constructPanedWideHandle val = constructObjectPropertyBool "wide-handle" val++data PanedWideHandlePropertyInfo+instance AttrInfo PanedWideHandlePropertyInfo where+    type AttrAllowedOps PanedWideHandlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PanedWideHandlePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PanedWideHandlePropertyInfo = PanedK+    type AttrGetType PanedWideHandlePropertyInfo = Bool+    type AttrLabel PanedWideHandlePropertyInfo = "Paned::wide-handle"+    attrGet _ = getPanedWideHandle+    attrSet _ = setPanedWideHandle+    attrConstruct _ = constructPanedWideHandle++type instance AttributeList Paned = PanedAttributeList+type PanedAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("max-position", PanedMaxPositionPropertyInfo), '("min-position", PanedMinPositionPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("position", PanedPositionPropertyInfo), '("position-set", PanedPositionSetPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("wide-handle", PanedWideHandlePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data PanedAcceptPositionSignalInfo+instance SignalInfo PanedAcceptPositionSignalInfo where+    type HaskellCallbackType PanedAcceptPositionSignalInfo = PanedAcceptPositionCallback+    connectSignal _ = connectPanedAcceptPosition++data PanedCancelPositionSignalInfo+instance SignalInfo PanedCancelPositionSignalInfo where+    type HaskellCallbackType PanedCancelPositionSignalInfo = PanedCancelPositionCallback+    connectSignal _ = connectPanedCancelPosition++data PanedCycleChildFocusSignalInfo+instance SignalInfo PanedCycleChildFocusSignalInfo where+    type HaskellCallbackType PanedCycleChildFocusSignalInfo = PanedCycleChildFocusCallback+    connectSignal _ = connectPanedCycleChildFocus++data PanedCycleHandleFocusSignalInfo+instance SignalInfo PanedCycleHandleFocusSignalInfo where+    type HaskellCallbackType PanedCycleHandleFocusSignalInfo = PanedCycleHandleFocusCallback+    connectSignal _ = connectPanedCycleHandleFocus++data PanedMoveHandleSignalInfo+instance SignalInfo PanedMoveHandleSignalInfo where+    type HaskellCallbackType PanedMoveHandleSignalInfo = PanedMoveHandleCallback+    connectSignal _ = connectPanedMoveHandle++data PanedToggleHandleFocusSignalInfo+instance SignalInfo PanedToggleHandleFocusSignalInfo where+    type HaskellCallbackType PanedToggleHandleFocusSignalInfo = PanedToggleHandleFocusCallback+    connectSignal _ = connectPanedToggleHandleFocus++type instance SignalList Paned = PanedSignalList+type PanedSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("accept-position", PanedAcceptPositionSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("cancel-position", PanedCancelPositionSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("cycle-child-focus", PanedCycleChildFocusSignalInfo), '("cycle-handle-focus", PanedCycleHandleFocusSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-handle", PanedMoveHandleSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-handle-focus", PanedToggleHandleFocusSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Paned::new+-- method type : Constructor+-- Args : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "orientation", argType = TInterface "Gtk" "Orientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Paned"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_new" gtk_paned_new :: +    CUInt ->                                -- orientation : TInterface "Gtk" "Orientation"+    IO (Ptr Paned)+++panedNew ::+    (MonadIO m) =>+    Orientation ->                          -- orientation+    m Paned+panedNew orientation = liftIO $ do+    let orientation' = (fromIntegral . fromEnum) orientation+    result <- gtk_paned_new orientation'+    checkUnexpectedReturnNULL "gtk_paned_new" result+    result' <- (newObject Paned) result+    return result'++-- method Paned::add1+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_add1" gtk_paned_add1 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++panedAdd1 ::+    (MonadIO m, PanedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+panedAdd1 _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_paned_add1 _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Paned::add2+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_add2" gtk_paned_add2 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    IO ()+++panedAdd2 ::+    (MonadIO m, PanedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    m ()+panedAdd2 _obj child = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    gtk_paned_add2 _obj' child'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Paned::get_child1+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_get_child1" gtk_paned_get_child1 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    IO (Ptr Widget)+++panedGetChild1 ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    m Widget+panedGetChild1 _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_paned_get_child1 _obj'+    checkUnexpectedReturnNULL "gtk_paned_get_child1" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Paned::get_child2+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_get_child2" gtk_paned_get_child2 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    IO (Ptr Widget)+++panedGetChild2 ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    m Widget+panedGetChild2 _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_paned_get_child2 _obj'+    checkUnexpectedReturnNULL "gtk_paned_get_child2" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Paned::get_handle_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_get_handle_window" gtk_paned_get_handle_window :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    IO (Ptr Gdk.Window)+++panedGetHandleWindow ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    m Gdk.Window+panedGetHandleWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_paned_get_handle_window _obj'+    checkUnexpectedReturnNULL "gtk_paned_get_handle_window" result+    result' <- (newObject Gdk.Window) result+    touchManagedPtr _obj+    return result'++-- method Paned::get_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_get_position" gtk_paned_get_position :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    IO Int32+++panedGetPosition ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    m Int32+panedGetPosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_paned_get_position _obj'+    touchManagedPtr _obj+    return result++-- method Paned::get_wide_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_paned_get_wide_handle" gtk_paned_get_wide_handle :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    IO CInt+++panedGetWideHandle ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    m Bool+panedGetWideHandle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_paned_get_wide_handle _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Paned::pack1+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shrink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shrink", 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 "gtk_paned_pack1" gtk_paned_pack1 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- resize : TBasicType TBoolean+    CInt ->                                 -- shrink : TBasicType TBoolean+    IO ()+++panedPack1 ::+    (MonadIO m, PanedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- resize+    Bool ->                                 -- shrink+    m ()+panedPack1 _obj child resize shrink = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let resize' = (fromIntegral . fromEnum) resize+    let shrink' = (fromIntegral . fromEnum) shrink+    gtk_paned_pack1 _obj' child' resize' shrink'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Paned::pack2+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shrink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "child", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resize", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "shrink", 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 "gtk_paned_pack2" gtk_paned_pack2 :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    Ptr Widget ->                           -- child : TInterface "Gtk" "Widget"+    CInt ->                                 -- resize : TBasicType TBoolean+    CInt ->                                 -- shrink : TBasicType TBoolean+    IO ()+++panedPack2 ::+    (MonadIO m, PanedK a, WidgetK b) =>+    a ->                                    -- _obj+    b ->                                    -- child+    Bool ->                                 -- resize+    Bool ->                                 -- shrink+    m ()+panedPack2 _obj child resize shrink = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    let resize' = (fromIntegral . fromEnum) resize+    let shrink' = (fromIntegral . fromEnum) shrink+    gtk_paned_pack2 _obj' child' resize' shrink'+    touchManagedPtr _obj+    touchManagedPtr child+    return ()++-- method Paned::set_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", 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 "Gtk" "Paned", 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 "gtk_paned_set_position" gtk_paned_set_position :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    Int32 ->                                -- position : TBasicType TInt32+    IO ()+++panedSetPosition ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- position+    m ()+panedSetPosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_paned_set_position _obj' position+    touchManagedPtr _obj+    return ()++-- method Paned::set_wide_handle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wide", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Paned", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "wide", 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 "gtk_paned_set_wide_handle" gtk_paned_set_wide_handle :: +    Ptr Paned ->                            -- _obj : TInterface "Gtk" "Paned"+    CInt ->                                 -- wide : TBasicType TBoolean+    IO ()+++panedSetWideHandle ::+    (MonadIO m, PanedK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- wide+    m ()+panedSetWideHandle _obj wide = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let wide' = (fromIntegral . fromEnum) wide+    gtk_paned_set_wide_handle _obj' wide'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Paned.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gtk.Objects.Paned where++import Prelude ()+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 Paned = Paned (ForeignPtr Paned)+instance GObject Paned where+class GObject o => PanedK o+instance (GObject o, IsDescendantOf Paned o) => PanedK o+data PanedMaxPositionPropertyInfo+data PanedMinPositionPropertyInfo+data PanedPositionPropertyInfo+data PanedPositionSetPropertyInfo+data PanedWideHandlePropertyInfo+data PanedAcceptPositionSignalInfo+data PanedCancelPositionSignalInfo+data PanedCycleChildFocusSignalInfo+data PanedCycleHandleFocusSignalInfo+data PanedMoveHandleSignalInfo+data PanedToggleHandleFocusSignalInfo
+ GI/Gtk/Objects/PanedAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.PanedAccessible+    ( ++-- * Exported types+    PanedAccessible(..)                     ,+    PanedAccessibleK                        ,+    toPanedAccessible                       ,+    noPanedAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype PanedAccessible = PanedAccessible (ForeignPtr PanedAccessible)+foreign import ccall "gtk_paned_accessible_get_type"+    c_gtk_paned_accessible_get_type :: IO GType++type instance ParentTypes PanedAccessible = PanedAccessibleParentTypes+type PanedAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Value]++instance GObject PanedAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_paned_accessible_get_type+    ++class GObject o => PanedAccessibleK o+instance (GObject o, IsDescendantOf PanedAccessible o) => PanedAccessibleK o++toPanedAccessible :: PanedAccessibleK o => o -> IO PanedAccessible+toPanedAccessible = unsafeCastTo PanedAccessible++noPanedAccessible :: Maybe PanedAccessible+noPanedAccessible = Nothing++type instance AttributeList PanedAccessible = PanedAccessibleAttributeList+type PanedAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList PanedAccessible = PanedAccessibleSignalList+type PanedAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("value-changed", Atk.ValueValueChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/PanedAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.PanedAccessible where++import Prelude ()+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 PanedAccessible = PanedAccessible (ForeignPtr PanedAccessible)+instance GObject PanedAccessible where+class GObject o => PanedAccessibleK o+instance (GObject o, IsDescendantOf PanedAccessible o) => PanedAccessibleK o
+ GI/Gtk/Objects/PlacesSidebar.hs view
@@ -0,0 +1,1678 @@++{- |+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.Gtk.Objects.PlacesSidebar+    ( ++-- * Exported types+    PlacesSidebar(..)                       ,+    PlacesSidebarK                          ,+    toPlacesSidebar                         ,+    noPlacesSidebar                         ,+++ -- * Methods+-- ** placesSidebarAddShortcut+    placesSidebarAddShortcut                ,+++-- ** placesSidebarGetLocalOnly+    placesSidebarGetLocalOnly               ,+++-- ** placesSidebarGetLocation+    placesSidebarGetLocation                ,+++-- ** placesSidebarGetNthBookmark+    placesSidebarGetNthBookmark             ,+++-- ** placesSidebarGetOpenFlags+    placesSidebarGetOpenFlags               ,+++-- ** placesSidebarGetShowConnectToServer+    placesSidebarGetShowConnectToServer     ,+++-- ** placesSidebarGetShowDesktop+    placesSidebarGetShowDesktop             ,+++-- ** placesSidebarGetShowEnterLocation+    placesSidebarGetShowEnterLocation       ,+++-- ** placesSidebarGetShowOtherLocations+    placesSidebarGetShowOtherLocations      ,+++-- ** placesSidebarGetShowRecent+    placesSidebarGetShowRecent              ,+++-- ** placesSidebarGetShowTrash+    placesSidebarGetShowTrash               ,+++-- ** placesSidebarListShortcuts+    placesSidebarListShortcuts              ,+++-- ** placesSidebarNew+    placesSidebarNew                        ,+++-- ** placesSidebarRemoveShortcut+    placesSidebarRemoveShortcut             ,+++-- ** placesSidebarSetDropTargetsVisible+    placesSidebarSetDropTargetsVisible      ,+++-- ** placesSidebarSetLocalOnly+    placesSidebarSetLocalOnly               ,+++-- ** placesSidebarSetLocation+    placesSidebarSetLocation                ,+++-- ** placesSidebarSetOpenFlags+    placesSidebarSetOpenFlags               ,+++-- ** placesSidebarSetShowConnectToServer+    placesSidebarSetShowConnectToServer     ,+++-- ** placesSidebarSetShowDesktop+    placesSidebarSetShowDesktop             ,+++-- ** placesSidebarSetShowEnterLocation+    placesSidebarSetShowEnterLocation       ,+++-- ** placesSidebarSetShowOtherLocations+    placesSidebarSetShowOtherLocations      ,+++-- ** placesSidebarSetShowRecent+    placesSidebarSetShowRecent              ,+++-- ** placesSidebarSetShowTrash+    placesSidebarSetShowTrash               ,+++++ -- * Properties+-- ** LocalOnly+    PlacesSidebarLocalOnlyPropertyInfo      ,+    constructPlacesSidebarLocalOnly         ,+    getPlacesSidebarLocalOnly               ,+    setPlacesSidebarLocalOnly               ,+++-- ** Location+    PlacesSidebarLocationPropertyInfo       ,+    constructPlacesSidebarLocation          ,+    getPlacesSidebarLocation                ,+    setPlacesSidebarLocation                ,+++-- ** OpenFlags+    PlacesSidebarOpenFlagsPropertyInfo      ,+    constructPlacesSidebarOpenFlags         ,+    getPlacesSidebarOpenFlags               ,+    setPlacesSidebarOpenFlags               ,+++-- ** PopulateAll+    PlacesSidebarPopulateAllPropertyInfo    ,+    constructPlacesSidebarPopulateAll       ,+    getPlacesSidebarPopulateAll             ,+    setPlacesSidebarPopulateAll             ,+++-- ** ShowConnectToServer+    PlacesSidebarShowConnectToServerPropertyInfo,+    constructPlacesSidebarShowConnectToServer,+    getPlacesSidebarShowConnectToServer     ,+    setPlacesSidebarShowConnectToServer     ,+++-- ** ShowDesktop+    PlacesSidebarShowDesktopPropertyInfo    ,+    constructPlacesSidebarShowDesktop       ,+    getPlacesSidebarShowDesktop             ,+    setPlacesSidebarShowDesktop             ,+++-- ** ShowEnterLocation+    PlacesSidebarShowEnterLocationPropertyInfo,+    constructPlacesSidebarShowEnterLocation ,+    getPlacesSidebarShowEnterLocation       ,+    setPlacesSidebarShowEnterLocation       ,+++-- ** ShowOtherLocations+    PlacesSidebarShowOtherLocationsPropertyInfo,+    constructPlacesSidebarShowOtherLocations,+    getPlacesSidebarShowOtherLocations      ,+    setPlacesSidebarShowOtherLocations      ,+++-- ** ShowRecent+    PlacesSidebarShowRecentPropertyInfo     ,+    constructPlacesSidebarShowRecent        ,+    getPlacesSidebarShowRecent              ,+    setPlacesSidebarShowRecent              ,+++-- ** ShowTrash+    PlacesSidebarShowTrashPropertyInfo      ,+    constructPlacesSidebarShowTrash         ,+    getPlacesSidebarShowTrash               ,+    setPlacesSidebarShowTrash               ,+++++ -- * Signals+-- ** DragActionAsk+    PlacesSidebarDragActionAskCallback      ,+    PlacesSidebarDragActionAskCallbackC     ,+    PlacesSidebarDragActionAskSignalInfo    ,+    afterPlacesSidebarDragActionAsk         ,+    mkPlacesSidebarDragActionAskCallback    ,+    noPlacesSidebarDragActionAskCallback    ,+    onPlacesSidebarDragActionAsk            ,+    placesSidebarDragActionAskCallbackWrapper,+    placesSidebarDragActionAskClosure       ,+++-- ** DragActionRequested+    PlacesSidebarDragActionRequestedCallback,+    PlacesSidebarDragActionRequestedCallbackC,+    PlacesSidebarDragActionRequestedSignalInfo,+    afterPlacesSidebarDragActionRequested   ,+    mkPlacesSidebarDragActionRequestedCallback,+    noPlacesSidebarDragActionRequestedCallback,+    onPlacesSidebarDragActionRequested      ,+    placesSidebarDragActionRequestedCallbackWrapper,+    placesSidebarDragActionRequestedClosure ,+++-- ** DragPerformDrop+    PlacesSidebarDragPerformDropCallback    ,+    PlacesSidebarDragPerformDropCallbackC   ,+    PlacesSidebarDragPerformDropSignalInfo  ,+    afterPlacesSidebarDragPerformDrop       ,+    mkPlacesSidebarDragPerformDropCallback  ,+    noPlacesSidebarDragPerformDropCallback  ,+    onPlacesSidebarDragPerformDrop          ,+    placesSidebarDragPerformDropCallbackWrapper,+    placesSidebarDragPerformDropClosure     ,+++-- ** OpenLocation+    PlacesSidebarOpenLocationCallback       ,+    PlacesSidebarOpenLocationCallbackC      ,+    PlacesSidebarOpenLocationSignalInfo     ,+    afterPlacesSidebarOpenLocation          ,+    mkPlacesSidebarOpenLocationCallback     ,+    noPlacesSidebarOpenLocationCallback     ,+    onPlacesSidebarOpenLocation             ,+    placesSidebarOpenLocationCallbackWrapper,+    placesSidebarOpenLocationClosure        ,+++-- ** PopulatePopup+    PlacesSidebarPopulatePopupCallback      ,+    PlacesSidebarPopulatePopupCallbackC     ,+    PlacesSidebarPopulatePopupSignalInfo    ,+    afterPlacesSidebarPopulatePopup         ,+    mkPlacesSidebarPopulatePopupCallback    ,+    noPlacesSidebarPopulatePopupCallback    ,+    onPlacesSidebarPopulatePopup            ,+    placesSidebarPopulatePopupCallbackWrapper,+    placesSidebarPopulatePopupClosure       ,+++-- ** ShowConnectToServer+    PlacesSidebarShowConnectToServerCallback,+    PlacesSidebarShowConnectToServerCallbackC,+    PlacesSidebarShowConnectToServerSignalInfo,+    afterPlacesSidebarShowConnectToServer   ,+    mkPlacesSidebarShowConnectToServerCallback,+    noPlacesSidebarShowConnectToServerCallback,+    onPlacesSidebarShowConnectToServer      ,+    placesSidebarShowConnectToServerCallbackWrapper,+    placesSidebarShowConnectToServerClosure ,+++-- ** ShowEnterLocation+    PlacesSidebarShowEnterLocationCallback  ,+    PlacesSidebarShowEnterLocationCallbackC ,+    PlacesSidebarShowEnterLocationSignalInfo,+    afterPlacesSidebarShowEnterLocation     ,+    mkPlacesSidebarShowEnterLocationCallback,+    noPlacesSidebarShowEnterLocationCallback,+    onPlacesSidebarShowEnterLocation        ,+    placesSidebarShowEnterLocationCallbackWrapper,+    placesSidebarShowEnterLocationClosure   ,+++-- ** ShowErrorMessage+    PlacesSidebarShowErrorMessageCallback   ,+    PlacesSidebarShowErrorMessageCallbackC  ,+    PlacesSidebarShowErrorMessageSignalInfo ,+    afterPlacesSidebarShowErrorMessage      ,+    mkPlacesSidebarShowErrorMessageCallback ,+    noPlacesSidebarShowErrorMessageCallback ,+    onPlacesSidebarShowErrorMessage         ,+    placesSidebarShowErrorMessageCallbackWrapper,+    placesSidebarShowErrorMessageClosure    ,+++-- ** ShowOtherLocations+    PlacesSidebarShowOtherLocationsCallback ,+    PlacesSidebarShowOtherLocationsCallbackC,+    PlacesSidebarShowOtherLocationsSignalInfo,+    afterPlacesSidebarShowOtherLocations    ,+    mkPlacesSidebarShowOtherLocationsCallback,+    noPlacesSidebarShowOtherLocationsCallback,+    onPlacesSidebarShowOtherLocations       ,+    placesSidebarShowOtherLocationsCallbackWrapper,+    placesSidebarShowOtherLocationsClosure  ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Gio as Gio++newtype PlacesSidebar = PlacesSidebar (ForeignPtr PlacesSidebar)+foreign import ccall "gtk_places_sidebar_get_type"+    c_gtk_places_sidebar_get_type :: IO GType++type instance ParentTypes PlacesSidebar = PlacesSidebarParentTypes+type PlacesSidebarParentTypes = '[ScrolledWindow, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject PlacesSidebar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_places_sidebar_get_type+    ++class GObject o => PlacesSidebarK o+instance (GObject o, IsDescendantOf PlacesSidebar o) => PlacesSidebarK o++toPlacesSidebar :: PlacesSidebarK o => o -> IO PlacesSidebar+toPlacesSidebar = unsafeCastTo PlacesSidebar++noPlacesSidebar :: Maybe PlacesSidebar+noPlacesSidebar = Nothing++-- signal PlacesSidebar::drag-action-ask+type PlacesSidebarDragActionAskCallback =+    Int32 ->+    IO Int32++noPlacesSidebarDragActionAskCallback :: Maybe PlacesSidebarDragActionAskCallback+noPlacesSidebarDragActionAskCallback = Nothing++type PlacesSidebarDragActionAskCallbackC =+    Ptr () ->                               -- object+    Int32 ->+    Ptr () ->                               -- user_data+    IO Int32++foreign import ccall "wrapper"+    mkPlacesSidebarDragActionAskCallback :: PlacesSidebarDragActionAskCallbackC -> IO (FunPtr PlacesSidebarDragActionAskCallbackC)++placesSidebarDragActionAskClosure :: PlacesSidebarDragActionAskCallback -> IO Closure+placesSidebarDragActionAskClosure cb = newCClosure =<< mkPlacesSidebarDragActionAskCallback wrapped+    where wrapped = placesSidebarDragActionAskCallbackWrapper cb++placesSidebarDragActionAskCallbackWrapper ::+    PlacesSidebarDragActionAskCallback ->+    Ptr () ->+    Int32 ->+    Ptr () ->+    IO Int32+placesSidebarDragActionAskCallbackWrapper _cb _ actions _ = do+    result <- _cb  actions+    return result++onPlacesSidebarDragActionAsk :: (GObject a, MonadIO m) => a -> PlacesSidebarDragActionAskCallback -> m SignalHandlerId+onPlacesSidebarDragActionAsk obj cb = liftIO $ connectPlacesSidebarDragActionAsk obj cb SignalConnectBefore+afterPlacesSidebarDragActionAsk :: (GObject a, MonadIO m) => a -> PlacesSidebarDragActionAskCallback -> m SignalHandlerId+afterPlacesSidebarDragActionAsk obj cb = connectPlacesSidebarDragActionAsk obj cb SignalConnectAfter++connectPlacesSidebarDragActionAsk :: (GObject a, MonadIO m) =>+                                     a -> PlacesSidebarDragActionAskCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarDragActionAsk obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarDragActionAskCallback (placesSidebarDragActionAskCallbackWrapper cb)+    connectSignalFunPtr obj "drag-action-ask" cb' after++-- signal PlacesSidebar::drag-action-requested+type PlacesSidebarDragActionRequestedCallback =+    Gdk.DragContext ->+    Gio.File ->+    [Gio.File] ->+    IO Int32++noPlacesSidebarDragActionRequestedCallback :: Maybe PlacesSidebarDragActionRequestedCallback+noPlacesSidebarDragActionRequestedCallback = Nothing++type PlacesSidebarDragActionRequestedCallbackC =+    Ptr () ->                               -- object+    Ptr Gdk.DragContext ->+    Ptr Gio.File ->+    Ptr (GList (Ptr Gio.File)) ->+    Ptr () ->                               -- user_data+    IO Int32++foreign import ccall "wrapper"+    mkPlacesSidebarDragActionRequestedCallback :: PlacesSidebarDragActionRequestedCallbackC -> IO (FunPtr PlacesSidebarDragActionRequestedCallbackC)++placesSidebarDragActionRequestedClosure :: PlacesSidebarDragActionRequestedCallback -> IO Closure+placesSidebarDragActionRequestedClosure cb = newCClosure =<< mkPlacesSidebarDragActionRequestedCallback wrapped+    where wrapped = placesSidebarDragActionRequestedCallbackWrapper cb++placesSidebarDragActionRequestedCallbackWrapper ::+    PlacesSidebarDragActionRequestedCallback ->+    Ptr () ->+    Ptr Gdk.DragContext ->+    Ptr Gio.File ->+    Ptr (GList (Ptr Gio.File)) ->+    Ptr () ->+    IO Int32+placesSidebarDragActionRequestedCallbackWrapper _cb _ context dest_file source_file_list _ = do+    context' <- (newObject Gdk.DragContext) context+    dest_file' <- (newObject Gio.File) dest_file+    source_file_list' <- unpackGList source_file_list+    source_file_list'' <- mapM (newObject Gio.File) source_file_list'+    result <- _cb  context' dest_file' source_file_list''+    return result++onPlacesSidebarDragActionRequested :: (GObject a, MonadIO m) => a -> PlacesSidebarDragActionRequestedCallback -> m SignalHandlerId+onPlacesSidebarDragActionRequested obj cb = liftIO $ connectPlacesSidebarDragActionRequested obj cb SignalConnectBefore+afterPlacesSidebarDragActionRequested :: (GObject a, MonadIO m) => a -> PlacesSidebarDragActionRequestedCallback -> m SignalHandlerId+afterPlacesSidebarDragActionRequested obj cb = connectPlacesSidebarDragActionRequested obj cb SignalConnectAfter++connectPlacesSidebarDragActionRequested :: (GObject a, MonadIO m) =>+                                           a -> PlacesSidebarDragActionRequestedCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarDragActionRequested obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarDragActionRequestedCallback (placesSidebarDragActionRequestedCallbackWrapper cb)+    connectSignalFunPtr obj "drag-action-requested" cb' after++-- signal PlacesSidebar::drag-perform-drop+type PlacesSidebarDragPerformDropCallback =+    Gio.File ->+    [Gio.File] ->+    Int32 ->+    IO ()++noPlacesSidebarDragPerformDropCallback :: Maybe PlacesSidebarDragPerformDropCallback+noPlacesSidebarDragPerformDropCallback = Nothing++type PlacesSidebarDragPerformDropCallbackC =+    Ptr () ->                               -- object+    Ptr Gio.File ->+    Ptr (GList (Ptr Gio.File)) ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarDragPerformDropCallback :: PlacesSidebarDragPerformDropCallbackC -> IO (FunPtr PlacesSidebarDragPerformDropCallbackC)++placesSidebarDragPerformDropClosure :: PlacesSidebarDragPerformDropCallback -> IO Closure+placesSidebarDragPerformDropClosure cb = newCClosure =<< mkPlacesSidebarDragPerformDropCallback wrapped+    where wrapped = placesSidebarDragPerformDropCallbackWrapper cb++placesSidebarDragPerformDropCallbackWrapper ::+    PlacesSidebarDragPerformDropCallback ->+    Ptr () ->+    Ptr Gio.File ->+    Ptr (GList (Ptr Gio.File)) ->+    Int32 ->+    Ptr () ->+    IO ()+placesSidebarDragPerformDropCallbackWrapper _cb _ dest_file source_file_list action _ = do+    dest_file' <- (newObject Gio.File) dest_file+    source_file_list' <- unpackGList source_file_list+    source_file_list'' <- mapM (newObject Gio.File) source_file_list'+    _cb  dest_file' source_file_list'' action++onPlacesSidebarDragPerformDrop :: (GObject a, MonadIO m) => a -> PlacesSidebarDragPerformDropCallback -> m SignalHandlerId+onPlacesSidebarDragPerformDrop obj cb = liftIO $ connectPlacesSidebarDragPerformDrop obj cb SignalConnectBefore+afterPlacesSidebarDragPerformDrop :: (GObject a, MonadIO m) => a -> PlacesSidebarDragPerformDropCallback -> m SignalHandlerId+afterPlacesSidebarDragPerformDrop obj cb = connectPlacesSidebarDragPerformDrop obj cb SignalConnectAfter++connectPlacesSidebarDragPerformDrop :: (GObject a, MonadIO m) =>+                                       a -> PlacesSidebarDragPerformDropCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarDragPerformDrop obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarDragPerformDropCallback (placesSidebarDragPerformDropCallbackWrapper cb)+    connectSignalFunPtr obj "drag-perform-drop" cb' after++-- signal PlacesSidebar::open-location+type PlacesSidebarOpenLocationCallback =+    Gio.File ->+    [PlacesOpenFlags] ->+    IO ()++noPlacesSidebarOpenLocationCallback :: Maybe PlacesSidebarOpenLocationCallback+noPlacesSidebarOpenLocationCallback = Nothing++type PlacesSidebarOpenLocationCallbackC =+    Ptr () ->                               -- object+    Ptr Gio.File ->+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarOpenLocationCallback :: PlacesSidebarOpenLocationCallbackC -> IO (FunPtr PlacesSidebarOpenLocationCallbackC)++placesSidebarOpenLocationClosure :: PlacesSidebarOpenLocationCallback -> IO Closure+placesSidebarOpenLocationClosure cb = newCClosure =<< mkPlacesSidebarOpenLocationCallback wrapped+    where wrapped = placesSidebarOpenLocationCallbackWrapper cb++placesSidebarOpenLocationCallbackWrapper ::+    PlacesSidebarOpenLocationCallback ->+    Ptr () ->+    Ptr Gio.File ->+    CUInt ->+    Ptr () ->+    IO ()+placesSidebarOpenLocationCallbackWrapper _cb _ location open_flags _ = do+    location' <- (newObject Gio.File) location+    let open_flags' = wordToGFlags open_flags+    _cb  location' open_flags'++onPlacesSidebarOpenLocation :: (GObject a, MonadIO m) => a -> PlacesSidebarOpenLocationCallback -> m SignalHandlerId+onPlacesSidebarOpenLocation obj cb = liftIO $ connectPlacesSidebarOpenLocation obj cb SignalConnectBefore+afterPlacesSidebarOpenLocation :: (GObject a, MonadIO m) => a -> PlacesSidebarOpenLocationCallback -> m SignalHandlerId+afterPlacesSidebarOpenLocation obj cb = connectPlacesSidebarOpenLocation obj cb SignalConnectAfter++connectPlacesSidebarOpenLocation :: (GObject a, MonadIO m) =>+                                    a -> PlacesSidebarOpenLocationCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarOpenLocation obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarOpenLocationCallback (placesSidebarOpenLocationCallbackWrapper cb)+    connectSignalFunPtr obj "open-location" cb' after++-- signal PlacesSidebar::populate-popup+type PlacesSidebarPopulatePopupCallback =+    Widget ->+    Maybe Gio.File ->+    Maybe Gio.Volume ->+    IO ()++noPlacesSidebarPopulatePopupCallback :: Maybe PlacesSidebarPopulatePopupCallback+noPlacesSidebarPopulatePopupCallback = Nothing++type PlacesSidebarPopulatePopupCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr Gio.File ->+    Ptr Gio.Volume ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarPopulatePopupCallback :: PlacesSidebarPopulatePopupCallbackC -> IO (FunPtr PlacesSidebarPopulatePopupCallbackC)++placesSidebarPopulatePopupClosure :: PlacesSidebarPopulatePopupCallback -> IO Closure+placesSidebarPopulatePopupClosure cb = newCClosure =<< mkPlacesSidebarPopulatePopupCallback wrapped+    where wrapped = placesSidebarPopulatePopupCallbackWrapper cb++placesSidebarPopulatePopupCallbackWrapper ::+    PlacesSidebarPopulatePopupCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr Gio.File ->+    Ptr Gio.Volume ->+    Ptr () ->+    IO ()+placesSidebarPopulatePopupCallbackWrapper _cb _ container selected_item selected_volume _ = do+    container' <- (newObject Widget) container+    maybeSelected_item <-+        if selected_item == nullPtr+        then return Nothing+        else do+            selected_item' <- (newObject Gio.File) selected_item+            return $ Just selected_item'+    maybeSelected_volume <-+        if selected_volume == nullPtr+        then return Nothing+        else do+            selected_volume' <- (newObject Gio.Volume) selected_volume+            return $ Just selected_volume'+    _cb  container' maybeSelected_item maybeSelected_volume++onPlacesSidebarPopulatePopup :: (GObject a, MonadIO m) => a -> PlacesSidebarPopulatePopupCallback -> m SignalHandlerId+onPlacesSidebarPopulatePopup obj cb = liftIO $ connectPlacesSidebarPopulatePopup obj cb SignalConnectBefore+afterPlacesSidebarPopulatePopup :: (GObject a, MonadIO m) => a -> PlacesSidebarPopulatePopupCallback -> m SignalHandlerId+afterPlacesSidebarPopulatePopup obj cb = connectPlacesSidebarPopulatePopup obj cb SignalConnectAfter++connectPlacesSidebarPopulatePopup :: (GObject a, MonadIO m) =>+                                     a -> PlacesSidebarPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarPopulatePopup obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarPopulatePopupCallback (placesSidebarPopulatePopupCallbackWrapper cb)+    connectSignalFunPtr obj "populate-popup" cb' after++-- signal PlacesSidebar::show-connect-to-server+type PlacesSidebarShowConnectToServerCallback =+    IO ()++noPlacesSidebarShowConnectToServerCallback :: Maybe PlacesSidebarShowConnectToServerCallback+noPlacesSidebarShowConnectToServerCallback = Nothing++type PlacesSidebarShowConnectToServerCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarShowConnectToServerCallback :: PlacesSidebarShowConnectToServerCallbackC -> IO (FunPtr PlacesSidebarShowConnectToServerCallbackC)++placesSidebarShowConnectToServerClosure :: PlacesSidebarShowConnectToServerCallback -> IO Closure+placesSidebarShowConnectToServerClosure cb = newCClosure =<< mkPlacesSidebarShowConnectToServerCallback wrapped+    where wrapped = placesSidebarShowConnectToServerCallbackWrapper cb++placesSidebarShowConnectToServerCallbackWrapper ::+    PlacesSidebarShowConnectToServerCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+placesSidebarShowConnectToServerCallbackWrapper _cb _ _ = do+    _cb ++onPlacesSidebarShowConnectToServer :: (GObject a, MonadIO m) => a -> PlacesSidebarShowConnectToServerCallback -> m SignalHandlerId+onPlacesSidebarShowConnectToServer obj cb = liftIO $ connectPlacesSidebarShowConnectToServer obj cb SignalConnectBefore+afterPlacesSidebarShowConnectToServer :: (GObject a, MonadIO m) => a -> PlacesSidebarShowConnectToServerCallback -> m SignalHandlerId+afterPlacesSidebarShowConnectToServer obj cb = connectPlacesSidebarShowConnectToServer obj cb SignalConnectAfter++connectPlacesSidebarShowConnectToServer :: (GObject a, MonadIO m) =>+                                           a -> PlacesSidebarShowConnectToServerCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarShowConnectToServer obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarShowConnectToServerCallback (placesSidebarShowConnectToServerCallbackWrapper cb)+    connectSignalFunPtr obj "show-connect-to-server" cb' after++-- signal PlacesSidebar::show-enter-location+type PlacesSidebarShowEnterLocationCallback =+    IO ()++noPlacesSidebarShowEnterLocationCallback :: Maybe PlacesSidebarShowEnterLocationCallback+noPlacesSidebarShowEnterLocationCallback = Nothing++type PlacesSidebarShowEnterLocationCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarShowEnterLocationCallback :: PlacesSidebarShowEnterLocationCallbackC -> IO (FunPtr PlacesSidebarShowEnterLocationCallbackC)++placesSidebarShowEnterLocationClosure :: PlacesSidebarShowEnterLocationCallback -> IO Closure+placesSidebarShowEnterLocationClosure cb = newCClosure =<< mkPlacesSidebarShowEnterLocationCallback wrapped+    where wrapped = placesSidebarShowEnterLocationCallbackWrapper cb++placesSidebarShowEnterLocationCallbackWrapper ::+    PlacesSidebarShowEnterLocationCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+placesSidebarShowEnterLocationCallbackWrapper _cb _ _ = do+    _cb ++onPlacesSidebarShowEnterLocation :: (GObject a, MonadIO m) => a -> PlacesSidebarShowEnterLocationCallback -> m SignalHandlerId+onPlacesSidebarShowEnterLocation obj cb = liftIO $ connectPlacesSidebarShowEnterLocation obj cb SignalConnectBefore+afterPlacesSidebarShowEnterLocation :: (GObject a, MonadIO m) => a -> PlacesSidebarShowEnterLocationCallback -> m SignalHandlerId+afterPlacesSidebarShowEnterLocation obj cb = connectPlacesSidebarShowEnterLocation obj cb SignalConnectAfter++connectPlacesSidebarShowEnterLocation :: (GObject a, MonadIO m) =>+                                         a -> PlacesSidebarShowEnterLocationCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarShowEnterLocation obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarShowEnterLocationCallback (placesSidebarShowEnterLocationCallbackWrapper cb)+    connectSignalFunPtr obj "show-enter-location" cb' after++-- signal PlacesSidebar::show-error-message+type PlacesSidebarShowErrorMessageCallback =+    T.Text ->+    T.Text ->+    IO ()++noPlacesSidebarShowErrorMessageCallback :: Maybe PlacesSidebarShowErrorMessageCallback+noPlacesSidebarShowErrorMessageCallback = Nothing++type PlacesSidebarShowErrorMessageCallbackC =+    Ptr () ->                               -- object+    CString ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarShowErrorMessageCallback :: PlacesSidebarShowErrorMessageCallbackC -> IO (FunPtr PlacesSidebarShowErrorMessageCallbackC)++placesSidebarShowErrorMessageClosure :: PlacesSidebarShowErrorMessageCallback -> IO Closure+placesSidebarShowErrorMessageClosure cb = newCClosure =<< mkPlacesSidebarShowErrorMessageCallback wrapped+    where wrapped = placesSidebarShowErrorMessageCallbackWrapper cb++placesSidebarShowErrorMessageCallbackWrapper ::+    PlacesSidebarShowErrorMessageCallback ->+    Ptr () ->+    CString ->+    CString ->+    Ptr () ->+    IO ()+placesSidebarShowErrorMessageCallbackWrapper _cb _ primary secondary _ = do+    primary' <- cstringToText primary+    secondary' <- cstringToText secondary+    _cb  primary' secondary'++onPlacesSidebarShowErrorMessage :: (GObject a, MonadIO m) => a -> PlacesSidebarShowErrorMessageCallback -> m SignalHandlerId+onPlacesSidebarShowErrorMessage obj cb = liftIO $ connectPlacesSidebarShowErrorMessage obj cb SignalConnectBefore+afterPlacesSidebarShowErrorMessage :: (GObject a, MonadIO m) => a -> PlacesSidebarShowErrorMessageCallback -> m SignalHandlerId+afterPlacesSidebarShowErrorMessage obj cb = connectPlacesSidebarShowErrorMessage obj cb SignalConnectAfter++connectPlacesSidebarShowErrorMessage :: (GObject a, MonadIO m) =>+                                        a -> PlacesSidebarShowErrorMessageCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarShowErrorMessage obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarShowErrorMessageCallback (placesSidebarShowErrorMessageCallbackWrapper cb)+    connectSignalFunPtr obj "show-error-message" cb' after++-- signal PlacesSidebar::show-other-locations+type PlacesSidebarShowOtherLocationsCallback =+    IO ()++noPlacesSidebarShowOtherLocationsCallback :: Maybe PlacesSidebarShowOtherLocationsCallback+noPlacesSidebarShowOtherLocationsCallback = Nothing++type PlacesSidebarShowOtherLocationsCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlacesSidebarShowOtherLocationsCallback :: PlacesSidebarShowOtherLocationsCallbackC -> IO (FunPtr PlacesSidebarShowOtherLocationsCallbackC)++placesSidebarShowOtherLocationsClosure :: PlacesSidebarShowOtherLocationsCallback -> IO Closure+placesSidebarShowOtherLocationsClosure cb = newCClosure =<< mkPlacesSidebarShowOtherLocationsCallback wrapped+    where wrapped = placesSidebarShowOtherLocationsCallbackWrapper cb++placesSidebarShowOtherLocationsCallbackWrapper ::+    PlacesSidebarShowOtherLocationsCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+placesSidebarShowOtherLocationsCallbackWrapper _cb _ _ = do+    _cb ++onPlacesSidebarShowOtherLocations :: (GObject a, MonadIO m) => a -> PlacesSidebarShowOtherLocationsCallback -> m SignalHandlerId+onPlacesSidebarShowOtherLocations obj cb = liftIO $ connectPlacesSidebarShowOtherLocations obj cb SignalConnectBefore+afterPlacesSidebarShowOtherLocations :: (GObject a, MonadIO m) => a -> PlacesSidebarShowOtherLocationsCallback -> m SignalHandlerId+afterPlacesSidebarShowOtherLocations obj cb = connectPlacesSidebarShowOtherLocations obj cb SignalConnectAfter++connectPlacesSidebarShowOtherLocations :: (GObject a, MonadIO m) =>+                                          a -> PlacesSidebarShowOtherLocationsCallback -> SignalConnectMode -> m SignalHandlerId+connectPlacesSidebarShowOtherLocations obj cb after = liftIO $ do+    cb' <- mkPlacesSidebarShowOtherLocationsCallback (placesSidebarShowOtherLocationsCallbackWrapper cb)+    connectSignalFunPtr obj "show-other-locations" cb' after++-- VVV Prop "local-only"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarLocalOnly :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarLocalOnly obj = liftIO $ getObjectPropertyBool obj "local-only"++setPlacesSidebarLocalOnly :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarLocalOnly obj val = liftIO $ setObjectPropertyBool obj "local-only" val++constructPlacesSidebarLocalOnly :: Bool -> IO ([Char], GValue)+constructPlacesSidebarLocalOnly val = constructObjectPropertyBool "local-only" val++data PlacesSidebarLocalOnlyPropertyInfo+instance AttrInfo PlacesSidebarLocalOnlyPropertyInfo where+    type AttrAllowedOps PlacesSidebarLocalOnlyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarLocalOnlyPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarLocalOnlyPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarLocalOnlyPropertyInfo = Bool+    type AttrLabel PlacesSidebarLocalOnlyPropertyInfo = "PlacesSidebar::local-only"+    attrGet _ = getPlacesSidebarLocalOnly+    attrSet _ = setPlacesSidebarLocalOnly+    attrConstruct _ = constructPlacesSidebarLocalOnly++-- VVV Prop "location"+   -- Type: TInterface "Gio" "File"+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarLocation :: (MonadIO m, PlacesSidebarK o) => o -> m Gio.File+getPlacesSidebarLocation obj = liftIO $ getObjectPropertyObject obj "location" Gio.File++setPlacesSidebarLocation :: (MonadIO m, PlacesSidebarK o, Gio.FileK a) => o -> a -> m ()+setPlacesSidebarLocation obj val = liftIO $ setObjectPropertyObject obj "location" val++constructPlacesSidebarLocation :: (Gio.FileK a) => a -> IO ([Char], GValue)+constructPlacesSidebarLocation val = constructObjectPropertyObject "location" val++data PlacesSidebarLocationPropertyInfo+instance AttrInfo PlacesSidebarLocationPropertyInfo where+    type AttrAllowedOps PlacesSidebarLocationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarLocationPropertyInfo = Gio.FileK+    type AttrBaseTypeConstraint PlacesSidebarLocationPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarLocationPropertyInfo = Gio.File+    type AttrLabel PlacesSidebarLocationPropertyInfo = "PlacesSidebar::location"+    attrGet _ = getPlacesSidebarLocation+    attrSet _ = setPlacesSidebarLocation+    attrConstruct _ = constructPlacesSidebarLocation++-- VVV Prop "open-flags"+   -- Type: TInterface "Gtk" "PlacesOpenFlags"+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarOpenFlags :: (MonadIO m, PlacesSidebarK o) => o -> m [PlacesOpenFlags]+getPlacesSidebarOpenFlags obj = liftIO $ getObjectPropertyFlags obj "open-flags"++setPlacesSidebarOpenFlags :: (MonadIO m, PlacesSidebarK o) => o -> [PlacesOpenFlags] -> m ()+setPlacesSidebarOpenFlags obj val = liftIO $ setObjectPropertyFlags obj "open-flags" val++constructPlacesSidebarOpenFlags :: [PlacesOpenFlags] -> IO ([Char], GValue)+constructPlacesSidebarOpenFlags val = constructObjectPropertyFlags "open-flags" val++data PlacesSidebarOpenFlagsPropertyInfo+instance AttrInfo PlacesSidebarOpenFlagsPropertyInfo where+    type AttrAllowedOps PlacesSidebarOpenFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarOpenFlagsPropertyInfo = (~) [PlacesOpenFlags]+    type AttrBaseTypeConstraint PlacesSidebarOpenFlagsPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarOpenFlagsPropertyInfo = [PlacesOpenFlags]+    type AttrLabel PlacesSidebarOpenFlagsPropertyInfo = "PlacesSidebar::open-flags"+    attrGet _ = getPlacesSidebarOpenFlags+    attrSet _ = setPlacesSidebarOpenFlags+    attrConstruct _ = constructPlacesSidebarOpenFlags++-- VVV Prop "populate-all"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarPopulateAll :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarPopulateAll obj = liftIO $ getObjectPropertyBool obj "populate-all"++setPlacesSidebarPopulateAll :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarPopulateAll obj val = liftIO $ setObjectPropertyBool obj "populate-all" val++constructPlacesSidebarPopulateAll :: Bool -> IO ([Char], GValue)+constructPlacesSidebarPopulateAll val = constructObjectPropertyBool "populate-all" val++data PlacesSidebarPopulateAllPropertyInfo+instance AttrInfo PlacesSidebarPopulateAllPropertyInfo where+    type AttrAllowedOps PlacesSidebarPopulateAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarPopulateAllPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarPopulateAllPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarPopulateAllPropertyInfo = Bool+    type AttrLabel PlacesSidebarPopulateAllPropertyInfo = "PlacesSidebar::populate-all"+    attrGet _ = getPlacesSidebarPopulateAll+    attrSet _ = setPlacesSidebarPopulateAll+    attrConstruct _ = constructPlacesSidebarPopulateAll++-- VVV Prop "show-connect-to-server"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowConnectToServer :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowConnectToServer obj = liftIO $ getObjectPropertyBool obj "show-connect-to-server"++setPlacesSidebarShowConnectToServer :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowConnectToServer obj val = liftIO $ setObjectPropertyBool obj "show-connect-to-server" val++constructPlacesSidebarShowConnectToServer :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowConnectToServer val = constructObjectPropertyBool "show-connect-to-server" val++data PlacesSidebarShowConnectToServerPropertyInfo+instance AttrInfo PlacesSidebarShowConnectToServerPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowConnectToServerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowConnectToServerPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowConnectToServerPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowConnectToServerPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowConnectToServerPropertyInfo = "PlacesSidebar::show-connect-to-server"+    attrGet _ = getPlacesSidebarShowConnectToServer+    attrSet _ = setPlacesSidebarShowConnectToServer+    attrConstruct _ = constructPlacesSidebarShowConnectToServer++-- VVV Prop "show-desktop"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowDesktop :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowDesktop obj = liftIO $ getObjectPropertyBool obj "show-desktop"++setPlacesSidebarShowDesktop :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowDesktop obj val = liftIO $ setObjectPropertyBool obj "show-desktop" val++constructPlacesSidebarShowDesktop :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowDesktop val = constructObjectPropertyBool "show-desktop" val++data PlacesSidebarShowDesktopPropertyInfo+instance AttrInfo PlacesSidebarShowDesktopPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowDesktopPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowDesktopPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowDesktopPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowDesktopPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowDesktopPropertyInfo = "PlacesSidebar::show-desktop"+    attrGet _ = getPlacesSidebarShowDesktop+    attrSet _ = setPlacesSidebarShowDesktop+    attrConstruct _ = constructPlacesSidebarShowDesktop++-- VVV Prop "show-enter-location"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowEnterLocation :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowEnterLocation obj = liftIO $ getObjectPropertyBool obj "show-enter-location"++setPlacesSidebarShowEnterLocation :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowEnterLocation obj val = liftIO $ setObjectPropertyBool obj "show-enter-location" val++constructPlacesSidebarShowEnterLocation :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowEnterLocation val = constructObjectPropertyBool "show-enter-location" val++data PlacesSidebarShowEnterLocationPropertyInfo+instance AttrInfo PlacesSidebarShowEnterLocationPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowEnterLocationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowEnterLocationPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowEnterLocationPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowEnterLocationPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowEnterLocationPropertyInfo = "PlacesSidebar::show-enter-location"+    attrGet _ = getPlacesSidebarShowEnterLocation+    attrSet _ = setPlacesSidebarShowEnterLocation+    attrConstruct _ = constructPlacesSidebarShowEnterLocation++-- VVV Prop "show-other-locations"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowOtherLocations :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowOtherLocations obj = liftIO $ getObjectPropertyBool obj "show-other-locations"++setPlacesSidebarShowOtherLocations :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowOtherLocations obj val = liftIO $ setObjectPropertyBool obj "show-other-locations" val++constructPlacesSidebarShowOtherLocations :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowOtherLocations val = constructObjectPropertyBool "show-other-locations" val++data PlacesSidebarShowOtherLocationsPropertyInfo+instance AttrInfo PlacesSidebarShowOtherLocationsPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowOtherLocationsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowOtherLocationsPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowOtherLocationsPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowOtherLocationsPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowOtherLocationsPropertyInfo = "PlacesSidebar::show-other-locations"+    attrGet _ = getPlacesSidebarShowOtherLocations+    attrSet _ = setPlacesSidebarShowOtherLocations+    attrConstruct _ = constructPlacesSidebarShowOtherLocations++-- VVV Prop "show-recent"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowRecent :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowRecent obj = liftIO $ getObjectPropertyBool obj "show-recent"++setPlacesSidebarShowRecent :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowRecent obj val = liftIO $ setObjectPropertyBool obj "show-recent" val++constructPlacesSidebarShowRecent :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowRecent val = constructObjectPropertyBool "show-recent" val++data PlacesSidebarShowRecentPropertyInfo+instance AttrInfo PlacesSidebarShowRecentPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowRecentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowRecentPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowRecentPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowRecentPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowRecentPropertyInfo = "PlacesSidebar::show-recent"+    attrGet _ = getPlacesSidebarShowRecent+    attrSet _ = setPlacesSidebarShowRecent+    attrConstruct _ = constructPlacesSidebarShowRecent++-- VVV Prop "show-trash"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPlacesSidebarShowTrash :: (MonadIO m, PlacesSidebarK o) => o -> m Bool+getPlacesSidebarShowTrash obj = liftIO $ getObjectPropertyBool obj "show-trash"++setPlacesSidebarShowTrash :: (MonadIO m, PlacesSidebarK o) => o -> Bool -> m ()+setPlacesSidebarShowTrash obj val = liftIO $ setObjectPropertyBool obj "show-trash" val++constructPlacesSidebarShowTrash :: Bool -> IO ([Char], GValue)+constructPlacesSidebarShowTrash val = constructObjectPropertyBool "show-trash" val++data PlacesSidebarShowTrashPropertyInfo+instance AttrInfo PlacesSidebarShowTrashPropertyInfo where+    type AttrAllowedOps PlacesSidebarShowTrashPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PlacesSidebarShowTrashPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PlacesSidebarShowTrashPropertyInfo = PlacesSidebarK+    type AttrGetType PlacesSidebarShowTrashPropertyInfo = Bool+    type AttrLabel PlacesSidebarShowTrashPropertyInfo = "PlacesSidebar::show-trash"+    attrGet _ = getPlacesSidebarShowTrash+    attrSet _ = setPlacesSidebarShowTrash+    attrConstruct _ = constructPlacesSidebarShowTrash++type instance AttributeList PlacesSidebar = PlacesSidebarAttributeList+type PlacesSidebarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("hadjustment", ScrolledWindowHadjustmentPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hscrollbar-policy", ScrolledWindowHscrollbarPolicyPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("kinetic-scrolling", ScrolledWindowKineticScrollingPropertyInfo), '("local-only", PlacesSidebarLocalOnlyPropertyInfo), '("location", PlacesSidebarLocationPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("min-content-height", ScrolledWindowMinContentHeightPropertyInfo), '("min-content-width", ScrolledWindowMinContentWidthPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("open-flags", PlacesSidebarOpenFlagsPropertyInfo), '("overlay-scrolling", ScrolledWindowOverlayScrollingPropertyInfo), '("parent", WidgetParentPropertyInfo), '("populate-all", PlacesSidebarPopulateAllPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("shadow-type", ScrolledWindowShadowTypePropertyInfo), '("show-connect-to-server", PlacesSidebarShowConnectToServerPropertyInfo), '("show-desktop", PlacesSidebarShowDesktopPropertyInfo), '("show-enter-location", PlacesSidebarShowEnterLocationPropertyInfo), '("show-other-locations", PlacesSidebarShowOtherLocationsPropertyInfo), '("show-recent", PlacesSidebarShowRecentPropertyInfo), '("show-trash", PlacesSidebarShowTrashPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("vadjustment", ScrolledWindowVadjustmentPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("vscrollbar-policy", ScrolledWindowVscrollbarPolicyPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-placement", ScrolledWindowWindowPlacementPropertyInfo), '("window-placement-set", ScrolledWindowWindowPlacementSetPropertyInfo)] :: [(Symbol, *)])++data PlacesSidebarDragActionAskSignalInfo+instance SignalInfo PlacesSidebarDragActionAskSignalInfo where+    type HaskellCallbackType PlacesSidebarDragActionAskSignalInfo = PlacesSidebarDragActionAskCallback+    connectSignal _ = connectPlacesSidebarDragActionAsk++data PlacesSidebarDragActionRequestedSignalInfo+instance SignalInfo PlacesSidebarDragActionRequestedSignalInfo where+    type HaskellCallbackType PlacesSidebarDragActionRequestedSignalInfo = PlacesSidebarDragActionRequestedCallback+    connectSignal _ = connectPlacesSidebarDragActionRequested++data PlacesSidebarDragPerformDropSignalInfo+instance SignalInfo PlacesSidebarDragPerformDropSignalInfo where+    type HaskellCallbackType PlacesSidebarDragPerformDropSignalInfo = PlacesSidebarDragPerformDropCallback+    connectSignal _ = connectPlacesSidebarDragPerformDrop++data PlacesSidebarOpenLocationSignalInfo+instance SignalInfo PlacesSidebarOpenLocationSignalInfo where+    type HaskellCallbackType PlacesSidebarOpenLocationSignalInfo = PlacesSidebarOpenLocationCallback+    connectSignal _ = connectPlacesSidebarOpenLocation++data PlacesSidebarPopulatePopupSignalInfo+instance SignalInfo PlacesSidebarPopulatePopupSignalInfo where+    type HaskellCallbackType PlacesSidebarPopulatePopupSignalInfo = PlacesSidebarPopulatePopupCallback+    connectSignal _ = connectPlacesSidebarPopulatePopup++data PlacesSidebarShowConnectToServerSignalInfo+instance SignalInfo PlacesSidebarShowConnectToServerSignalInfo where+    type HaskellCallbackType PlacesSidebarShowConnectToServerSignalInfo = PlacesSidebarShowConnectToServerCallback+    connectSignal _ = connectPlacesSidebarShowConnectToServer++data PlacesSidebarShowEnterLocationSignalInfo+instance SignalInfo PlacesSidebarShowEnterLocationSignalInfo where+    type HaskellCallbackType PlacesSidebarShowEnterLocationSignalInfo = PlacesSidebarShowEnterLocationCallback+    connectSignal _ = connectPlacesSidebarShowEnterLocation++data PlacesSidebarShowErrorMessageSignalInfo+instance SignalInfo PlacesSidebarShowErrorMessageSignalInfo where+    type HaskellCallbackType PlacesSidebarShowErrorMessageSignalInfo = PlacesSidebarShowErrorMessageCallback+    connectSignal _ = connectPlacesSidebarShowErrorMessage++data PlacesSidebarShowOtherLocationsSignalInfo+instance SignalInfo PlacesSidebarShowOtherLocationsSignalInfo where+    type HaskellCallbackType PlacesSidebarShowOtherLocationsSignalInfo = PlacesSidebarShowOtherLocationsCallback+    connectSignal _ = connectPlacesSidebarShowOtherLocations++type instance SignalList PlacesSidebar = PlacesSidebarSignalList+type PlacesSidebarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-action-ask", PlacesSidebarDragActionAskSignalInfo), '("drag-action-requested", PlacesSidebarDragActionRequestedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("drag-perform-drop", PlacesSidebarDragPerformDropSignalInfo), '("draw", WidgetDrawSignalInfo), '("edge-overshot", ScrolledWindowEdgeOvershotSignalInfo), '("edge-reached", ScrolledWindowEdgeReachedSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-focus-out", ScrolledWindowMoveFocusOutSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("open-location", PlacesSidebarOpenLocationSignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("populate-popup", PlacesSidebarPopulatePopupSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-child", ScrolledWindowScrollChildSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-connect-to-server", PlacesSidebarShowConnectToServerSignalInfo), '("show-enter-location", PlacesSidebarShowEnterLocationSignalInfo), '("show-error-message", PlacesSidebarShowErrorMessageSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("show-other-locations", PlacesSidebarShowOtherLocationsSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PlacesSidebar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "PlacesSidebar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_new" gtk_places_sidebar_new :: +    IO (Ptr PlacesSidebar)+++placesSidebarNew ::+    (MonadIO m) =>+    m PlacesSidebar+placesSidebarNew  = liftIO $ do+    result <- gtk_places_sidebar_new+    checkUnexpectedReturnNULL "gtk_places_sidebar_new" result+    result' <- (newObject PlacesSidebar) result+    return result'++-- method PlacesSidebar::add_shortcut+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_add_shortcut" gtk_places_sidebar_add_shortcut :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    Ptr Gio.File ->                         -- location : TInterface "Gio" "File"+    IO ()+++placesSidebarAddShortcut ::+    (MonadIO m, PlacesSidebarK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- location+    m ()+placesSidebarAddShortcut _obj location = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let location' = unsafeManagedPtrCastPtr location+    gtk_places_sidebar_add_shortcut _obj' location'+    touchManagedPtr _obj+    touchManagedPtr location+    return ()++-- method PlacesSidebar::get_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_local_only" gtk_places_sidebar_get_local_only :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetLocalOnly ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetLocalOnly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_local_only _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_location" gtk_places_sidebar_get_location :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO (Ptr Gio.File)+++placesSidebarGetLocation ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Gio.File+placesSidebarGetLocation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_location _obj'+    checkUnexpectedReturnNULL "gtk_places_sidebar_get_location" result+    result' <- (wrapObject Gio.File) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_nth_bookmark+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gio" "File"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_nth_bookmark" gtk_places_sidebar_get_nth_bookmark :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    Int32 ->                                -- n : TBasicType TInt32+    IO (Ptr Gio.File)+++placesSidebarGetNthBookmark ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n+    m Gio.File+placesSidebarGetNthBookmark _obj n = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_nth_bookmark _obj' n+    checkUnexpectedReturnNULL "gtk_places_sidebar_get_nth_bookmark" result+    result' <- (wrapObject Gio.File) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_open_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PlacesOpenFlags"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_open_flags" gtk_places_sidebar_get_open_flags :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CUInt+++placesSidebarGetOpenFlags ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m [PlacesOpenFlags]+placesSidebarGetOpenFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_open_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_connect_to_server+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_connect_to_server" gtk_places_sidebar_get_show_connect_to_server :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt++{-# DEPRECATED placesSidebarGetShowConnectToServer ["(Since version 3.18)","It is recommended to group this functionality with the drives","    and network location under the new 'Other Location' item"]#-}+placesSidebarGetShowConnectToServer ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowConnectToServer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_connect_to_server _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_desktop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_desktop" gtk_places_sidebar_get_show_desktop :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetShowDesktop ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowDesktop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_desktop _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_enter_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_enter_location" gtk_places_sidebar_get_show_enter_location :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetShowEnterLocation ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowEnterLocation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_enter_location _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_other_locations+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_other_locations" gtk_places_sidebar_get_show_other_locations :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetShowOtherLocations ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowOtherLocations _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_other_locations _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_recent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_recent" gtk_places_sidebar_get_show_recent :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetShowRecent ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowRecent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_recent _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::get_show_trash+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_get_show_trash" gtk_places_sidebar_get_show_trash :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO CInt+++placesSidebarGetShowTrash ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m Bool+placesSidebarGetShowTrash _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_get_show_trash _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PlacesSidebar::list_shortcuts+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gio" "File")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_list_shortcuts" gtk_places_sidebar_list_shortcuts :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    IO (Ptr (GSList (Ptr Gio.File)))+++placesSidebarListShortcuts ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    m [Gio.File]+placesSidebarListShortcuts _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_places_sidebar_list_shortcuts _obj'+    checkUnexpectedReturnNULL "gtk_places_sidebar_list_shortcuts" result+    result' <- unpackGSList result+    result'' <- mapM (wrapObject Gio.File) result'+    g_slist_free result+    touchManagedPtr _obj+    return result''++-- method PlacesSidebar::remove_shortcut+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_remove_shortcut" gtk_places_sidebar_remove_shortcut :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    Ptr Gio.File ->                         -- location : TInterface "Gio" "File"+    IO ()+++placesSidebarRemoveShortcut ::+    (MonadIO m, PlacesSidebarK a, Gio.FileK b) =>+    a ->                                    -- _obj+    b ->                                    -- location+    m ()+placesSidebarRemoveShortcut _obj location = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let location' = unsafeManagedPtrCastPtr location+    gtk_places_sidebar_remove_shortcut _obj' location'+    touchManagedPtr _obj+    touchManagedPtr location+    return ()++-- method PlacesSidebar::set_drop_targets_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "context", argType = TInterface "Gdk" "DragContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_set_drop_targets_visible" gtk_places_sidebar_set_drop_targets_visible :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- visible : TBasicType TBoolean+    Ptr Gdk.DragContext ->                  -- context : TInterface "Gdk" "DragContext"+    IO ()+++placesSidebarSetDropTargetsVisible ::+    (MonadIO m, PlacesSidebarK a, Gdk.DragContextK b) =>+    a ->                                    -- _obj+    Bool ->                                 -- visible+    b ->                                    -- context+    m ()+placesSidebarSetDropTargetsVisible _obj visible context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let visible' = (fromIntegral . fromEnum) visible+    let context' = unsafeManagedPtrCastPtr context+    gtk_places_sidebar_set_drop_targets_visible _obj' visible' context'+    touchManagedPtr _obj+    touchManagedPtr context+    return ()++-- method PlacesSidebar::set_local_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_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 "gtk_places_sidebar_set_local_only" gtk_places_sidebar_set_local_only :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- local_only : TBasicType TBoolean+    IO ()+++placesSidebarSetLocalOnly ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- local_only+    m ()+placesSidebarSetLocalOnly _obj local_only = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let local_only' = (fromIntegral . fromEnum) local_only+    gtk_places_sidebar_set_local_only _obj' local_only'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "location", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_set_location" gtk_places_sidebar_set_location :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    Ptr Gio.File ->                         -- location : TInterface "Gio" "File"+    IO ()+++placesSidebarSetLocation ::+    (MonadIO m, PlacesSidebarK a, Gio.FileK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- location+    m ()+placesSidebarSetLocation _obj location = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLocation <- case location of+        Nothing -> return nullPtr+        Just jLocation -> do+            let jLocation' = unsafeManagedPtrCastPtr jLocation+            return jLocation'+    gtk_places_sidebar_set_location _obj' maybeLocation+    touchManagedPtr _obj+    whenJust location touchManagedPtr+    return ()++-- method PlacesSidebar::set_open_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "PlacesOpenFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Gtk" "PlacesOpenFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_places_sidebar_set_open_flags" gtk_places_sidebar_set_open_flags :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CUInt ->                                -- flags : TInterface "Gtk" "PlacesOpenFlags"+    IO ()+++placesSidebarSetOpenFlags ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    [PlacesOpenFlags] ->                    -- flags+    m ()+placesSidebarSetOpenFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    gtk_places_sidebar_set_open_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_connect_to_server+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_connect_to_server", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_connect_to_server", 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 "gtk_places_sidebar_set_show_connect_to_server" gtk_places_sidebar_set_show_connect_to_server :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_connect_to_server : TBasicType TBoolean+    IO ()++{-# DEPRECATED placesSidebarSetShowConnectToServer ["(Since version 3.18)","It is recommended to group this functionality with the drives","    and network location under the new 'Other Location' item"]#-}+placesSidebarSetShowConnectToServer ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_connect_to_server+    m ()+placesSidebarSetShowConnectToServer _obj show_connect_to_server = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_connect_to_server' = (fromIntegral . fromEnum) show_connect_to_server+    gtk_places_sidebar_set_show_connect_to_server _obj' show_connect_to_server'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_desktop+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_desktop", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_desktop", 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 "gtk_places_sidebar_set_show_desktop" gtk_places_sidebar_set_show_desktop :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_desktop : TBasicType TBoolean+    IO ()+++placesSidebarSetShowDesktop ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_desktop+    m ()+placesSidebarSetShowDesktop _obj show_desktop = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_desktop' = (fromIntegral . fromEnum) show_desktop+    gtk_places_sidebar_set_show_desktop _obj' show_desktop'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_enter_location+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_enter_location", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_enter_location", 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 "gtk_places_sidebar_set_show_enter_location" gtk_places_sidebar_set_show_enter_location :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_enter_location : TBasicType TBoolean+    IO ()+++placesSidebarSetShowEnterLocation ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_enter_location+    m ()+placesSidebarSetShowEnterLocation _obj show_enter_location = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_enter_location' = (fromIntegral . fromEnum) show_enter_location+    gtk_places_sidebar_set_show_enter_location _obj' show_enter_location'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_other_locations+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_other_locations", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_other_locations", 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 "gtk_places_sidebar_set_show_other_locations" gtk_places_sidebar_set_show_other_locations :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_other_locations : TBasicType TBoolean+    IO ()+++placesSidebarSetShowOtherLocations ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_other_locations+    m ()+placesSidebarSetShowOtherLocations _obj show_other_locations = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_other_locations' = (fromIntegral . fromEnum) show_other_locations+    gtk_places_sidebar_set_show_other_locations _obj' show_other_locations'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_recent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_recent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_recent", 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 "gtk_places_sidebar_set_show_recent" gtk_places_sidebar_set_show_recent :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_recent : TBasicType TBoolean+    IO ()+++placesSidebarSetShowRecent ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_recent+    m ()+placesSidebarSetShowRecent _obj show_recent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_recent' = (fromIntegral . fromEnum) show_recent+    gtk_places_sidebar_set_show_recent _obj' show_recent'+    touchManagedPtr _obj+    return ()++-- method PlacesSidebar::set_show_trash+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_trash", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PlacesSidebar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_trash", 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 "gtk_places_sidebar_set_show_trash" gtk_places_sidebar_set_show_trash :: +    Ptr PlacesSidebar ->                    -- _obj : TInterface "Gtk" "PlacesSidebar"+    CInt ->                                 -- show_trash : TBasicType TBoolean+    IO ()+++placesSidebarSetShowTrash ::+    (MonadIO m, PlacesSidebarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_trash+    m ()+placesSidebarSetShowTrash _obj show_trash = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_trash' = (fromIntegral . fromEnum) show_trash+    gtk_places_sidebar_set_show_trash _obj' show_trash'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/PlacesSidebar.hs-boot view
@@ -0,0 +1,32 @@+module GI.Gtk.Objects.PlacesSidebar where++import Prelude ()+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 PlacesSidebar = PlacesSidebar (ForeignPtr PlacesSidebar)+instance GObject PlacesSidebar where+class GObject o => PlacesSidebarK o+instance (GObject o, IsDescendantOf PlacesSidebar o) => PlacesSidebarK o+data PlacesSidebarLocalOnlyPropertyInfo+data PlacesSidebarLocationPropertyInfo+data PlacesSidebarOpenFlagsPropertyInfo+data PlacesSidebarPopulateAllPropertyInfo+data PlacesSidebarShowConnectToServerPropertyInfo+data PlacesSidebarShowDesktopPropertyInfo+data PlacesSidebarShowEnterLocationPropertyInfo+data PlacesSidebarShowOtherLocationsPropertyInfo+data PlacesSidebarShowRecentPropertyInfo+data PlacesSidebarShowTrashPropertyInfo+data PlacesSidebarDragActionAskSignalInfo+data PlacesSidebarDragActionRequestedSignalInfo+data PlacesSidebarDragPerformDropSignalInfo+data PlacesSidebarOpenLocationSignalInfo+data PlacesSidebarPopulatePopupSignalInfo+data PlacesSidebarShowConnectToServerSignalInfo+data PlacesSidebarShowEnterLocationSignalInfo+data PlacesSidebarShowErrorMessageSignalInfo+data PlacesSidebarShowOtherLocationsSignalInfo
+ GI/Gtk/Objects/Plug.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)+-}++module GI.Gtk.Objects.Plug+    ( ++-- * Exported types+    Plug(..)                                ,+    PlugK                                   ,+    toPlug                                  ,+    noPlug                                  ,+++ -- * Methods+-- ** plugConstruct+    plugConstruct                           ,+++-- ** plugConstructForDisplay+    plugConstructForDisplay                 ,+++-- ** plugGetEmbedded+    plugGetEmbedded                         ,+++-- ** plugGetId+    plugGetId                               ,+++-- ** plugGetSocketWindow+    plugGetSocketWindow                     ,+++-- ** plugNew+    plugNew                                 ,+++-- ** plugNewForDisplay+    plugNewForDisplay                       ,+++++ -- * Properties+-- ** Embedded+    PlugEmbeddedPropertyInfo                ,+    getPlugEmbedded                         ,+++-- ** SocketWindow+    PlugSocketWindowPropertyInfo            ,+    getPlugSocketWindow                     ,+++++ -- * Signals+-- ** Embedded+    PlugEmbeddedCallback                    ,+    PlugEmbeddedCallbackC                   ,+    PlugEmbeddedSignalInfo                  ,+    afterPlugEmbedded                       ,+    mkPlugEmbeddedCallback                  ,+    noPlugEmbeddedCallback                  ,+    onPlugEmbedded                          ,+    plugEmbeddedCallbackWrapper             ,+    plugEmbeddedClosure                     ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Plug = Plug (ForeignPtr Plug)+foreign import ccall "gtk_plug_get_type"+    c_gtk_plug_get_type :: IO GType++type instance ParentTypes Plug = PlugParentTypes+type PlugParentTypes = '[Window, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Plug where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_plug_get_type+    ++class GObject o => PlugK o+instance (GObject o, IsDescendantOf Plug o) => PlugK o++toPlug :: PlugK o => o -> IO Plug+toPlug = unsafeCastTo Plug++noPlug :: Maybe Plug+noPlug = Nothing++-- signal Plug::embedded+type PlugEmbeddedCallback =+    IO ()++noPlugEmbeddedCallback :: Maybe PlugEmbeddedCallback+noPlugEmbeddedCallback = Nothing++type PlugEmbeddedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPlugEmbeddedCallback :: PlugEmbeddedCallbackC -> IO (FunPtr PlugEmbeddedCallbackC)++plugEmbeddedClosure :: PlugEmbeddedCallback -> IO Closure+plugEmbeddedClosure cb = newCClosure =<< mkPlugEmbeddedCallback wrapped+    where wrapped = plugEmbeddedCallbackWrapper cb++plugEmbeddedCallbackWrapper ::+    PlugEmbeddedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+plugEmbeddedCallbackWrapper _cb _ _ = do+    _cb ++onPlugEmbedded :: (GObject a, MonadIO m) => a -> PlugEmbeddedCallback -> m SignalHandlerId+onPlugEmbedded obj cb = liftIO $ connectPlugEmbedded obj cb SignalConnectBefore+afterPlugEmbedded :: (GObject a, MonadIO m) => a -> PlugEmbeddedCallback -> m SignalHandlerId+afterPlugEmbedded obj cb = connectPlugEmbedded obj cb SignalConnectAfter++connectPlugEmbedded :: (GObject a, MonadIO m) =>+                       a -> PlugEmbeddedCallback -> SignalConnectMode -> m SignalHandlerId+connectPlugEmbedded obj cb after = liftIO $ do+    cb' <- mkPlugEmbeddedCallback (plugEmbeddedCallbackWrapper cb)+    connectSignalFunPtr obj "embedded" cb' after++-- VVV Prop "embedded"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getPlugEmbedded :: (MonadIO m, PlugK o) => o -> m Bool+getPlugEmbedded obj = liftIO $ getObjectPropertyBool obj "embedded"++data PlugEmbeddedPropertyInfo+instance AttrInfo PlugEmbeddedPropertyInfo where+    type AttrAllowedOps PlugEmbeddedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PlugEmbeddedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PlugEmbeddedPropertyInfo = PlugK+    type AttrGetType PlugEmbeddedPropertyInfo = Bool+    type AttrLabel PlugEmbeddedPropertyInfo = "Plug::embedded"+    attrGet _ = getPlugEmbedded+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "socket-window"+   -- Type: TInterface "Gdk" "Window"+   -- Flags: [PropertyReadable]++getPlugSocketWindow :: (MonadIO m, PlugK o) => o -> m Gdk.Window+getPlugSocketWindow obj = liftIO $ getObjectPropertyObject obj "socket-window" Gdk.Window++data PlugSocketWindowPropertyInfo+instance AttrInfo PlugSocketWindowPropertyInfo where+    type AttrAllowedOps PlugSocketWindowPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PlugSocketWindowPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PlugSocketWindowPropertyInfo = PlugK+    type AttrGetType PlugSocketWindowPropertyInfo = Gdk.Window+    type AttrLabel PlugSocketWindowPropertyInfo = "Plug::socket-window"+    attrGet _ = getPlugSocketWindow+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Plug = PlugAttributeList+type PlugAttributeList = ('[ '("accept-focus", WindowAcceptFocusPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("application", WindowApplicationPropertyInfo), '("attached-to", WindowAttachedToPropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("decorated", WindowDecoratedPropertyInfo), '("default-height", WindowDefaultHeightPropertyInfo), '("default-width", WindowDefaultWidthPropertyInfo), '("deletable", WindowDeletablePropertyInfo), '("destroy-with-parent", WindowDestroyWithParentPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("embedded", PlugEmbeddedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-map", WindowFocusOnMapPropertyInfo), '("focus-visible", WindowFocusVisiblePropertyInfo), '("gravity", WindowGravityPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-resize-grip", WindowHasResizeGripPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("has-toplevel-focus", WindowHasToplevelFocusPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("hide-titlebar-when-maximized", WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", WindowIconPropertyInfo), '("icon-name", WindowIconNamePropertyInfo), '("is-active", WindowIsActivePropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-maximized", WindowIsMaximizedPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("mnemonics-visible", WindowMnemonicsVisiblePropertyInfo), '("modal", WindowModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("resizable", WindowResizablePropertyInfo), '("resize-grip-visible", WindowResizeGripVisiblePropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("role", WindowRolePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("screen", WindowScreenPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("skip-pager-hint", WindowSkipPagerHintPropertyInfo), '("skip-taskbar-hint", WindowSkipTaskbarHintPropertyInfo), '("socket-window", PlugSocketWindowPropertyInfo), '("startup-id", WindowStartupIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("title", WindowTitlePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transient-for", WindowTransientForPropertyInfo), '("type", WindowTypePropertyInfo), '("type-hint", WindowTypeHintPropertyInfo), '("urgency-hint", WindowUrgencyHintPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("window-position", WindowWindowPositionPropertyInfo)] :: [(Symbol, *)])++data PlugEmbeddedSignalInfo+instance SignalInfo PlugEmbeddedSignalInfo where+    type HaskellCallbackType PlugEmbeddedSignalInfo = PlugEmbeddedCallback+    connectSignal _ = connectPlugEmbedded++type instance SignalList Plug = PlugSignalList+type PlugSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate-default", WindowActivateDefaultSignalInfo), '("activate-focus", WindowActivateFocusSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("embedded", PlugEmbeddedSignalInfo), '("enable-debugging", WindowEnableDebuggingSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("keys-changed", WindowKeysChangedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus", WindowSetFocusSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Plug::new+-- method type : Constructor+-- Args : [Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Plug"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_plug_new" gtk_plug_new :: +    Word64 ->                               -- socket_id : TBasicType TUInt64+    IO (Ptr Plug)+++plugNew ::+    (MonadIO m) =>+    Word64 ->                               -- socket_id+    m Plug+plugNew socket_id = liftIO $ do+    result <- gtk_plug_new socket_id+    checkUnexpectedReturnNULL "gtk_plug_new" result+    result' <- (newObject Plug) result+    return result'++-- method Plug::new_for_display+-- method type : Constructor+-- Args : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Plug"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_plug_new_for_display" gtk_plug_new_for_display :: +    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Word64 ->                               -- socket_id : TBasicType TUInt64+    IO (Ptr Plug)+++plugNewForDisplay ::+    (MonadIO m, Gdk.DisplayK a) =>+    a ->                                    -- display+    Word64 ->                               -- socket_id+    m Plug+plugNewForDisplay display socket_id = liftIO $ do+    let display' = unsafeManagedPtrCastPtr display+    result <- gtk_plug_new_for_display display' socket_id+    checkUnexpectedReturnNULL "gtk_plug_new_for_display" result+    result' <- (newObject Plug) result+    touchManagedPtr display+    return result'++-- method Plug::construct+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_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 "gtk_plug_construct" gtk_plug_construct :: +    Ptr Plug ->                             -- _obj : TInterface "Gtk" "Plug"+    Word64 ->                               -- socket_id : TBasicType TUInt64+    IO ()+++plugConstruct ::+    (MonadIO m, PlugK a) =>+    a ->                                    -- _obj+    Word64 ->                               -- socket_id+    m ()+plugConstruct _obj socket_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_plug_construct _obj' socket_id+    touchManagedPtr _obj+    return ()++-- method Plug::construct_for_display+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "display", argType = TInterface "Gdk" "Display", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket_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 "gtk_plug_construct_for_display" gtk_plug_construct_for_display :: +    Ptr Plug ->                             -- _obj : TInterface "Gtk" "Plug"+    Ptr Gdk.Display ->                      -- display : TInterface "Gdk" "Display"+    Word64 ->                               -- socket_id : TBasicType TUInt64+    IO ()+++plugConstructForDisplay ::+    (MonadIO m, PlugK a, Gdk.DisplayK b) =>+    a ->                                    -- _obj+    b ->                                    -- display+    Word64 ->                               -- socket_id+    m ()+plugConstructForDisplay _obj display socket_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let display' = unsafeManagedPtrCastPtr display+    gtk_plug_construct_for_display _obj' display' socket_id+    touchManagedPtr _obj+    touchManagedPtr display+    return ()++-- method Plug::get_embedded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_plug_get_embedded" gtk_plug_get_embedded :: +    Ptr Plug ->                             -- _obj : TInterface "Gtk" "Plug"+    IO CInt+++plugGetEmbedded ::+    (MonadIO m, PlugK a) =>+    a ->                                    -- _obj+    m Bool+plugGetEmbedded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_plug_get_embedded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Plug::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gtk_plug_get_id" gtk_plug_get_id :: +    Ptr Plug ->                             -- _obj : TInterface "Gtk" "Plug"+    IO Word64+++plugGetId ::+    (MonadIO m, PlugK a) =>+    a ->                                    -- _obj+    m Word64+plugGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_plug_get_id _obj'+    touchManagedPtr _obj+    return result++-- method Plug::get_socket_window+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Plug", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gdk" "Window"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_plug_get_socket_window" gtk_plug_get_socket_window :: +    Ptr Plug ->                             -- _obj : TInterface "Gtk" "Plug"+    IO (Ptr Gdk.Window)+++plugGetSocketWindow ::+    (MonadIO m, PlugK a) =>+    a ->                                    -- _obj+    m Gdk.Window+plugGetSocketWindow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_plug_get_socket_window _obj'+    checkUnexpectedReturnNULL "gtk_plug_get_socket_window" result+    result' <- (newObject Gdk.Window) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/Plug.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gtk.Objects.Plug where++import Prelude ()+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 Plug = Plug (ForeignPtr Plug)+instance GObject Plug where+class GObject o => PlugK o+instance (GObject o, IsDescendantOf Plug o) => PlugK o+data PlugEmbeddedPropertyInfo+data PlugSocketWindowPropertyInfo+data PlugEmbeddedSignalInfo
+ GI/Gtk/Objects/Popover.hs view
@@ -0,0 +1,772 @@++{- |+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.Gtk.Objects.Popover+    ( ++-- * Exported types+    Popover(..)                             ,+    PopoverK                                ,+    toPopover                               ,+    noPopover                               ,+++ -- * Methods+-- ** popoverBindModel+    popoverBindModel                        ,+++-- ** popoverGetDefaultWidget+    popoverGetDefaultWidget                 ,+++-- ** popoverGetModal+    popoverGetModal                         ,+++-- ** popoverGetPointingTo+    popoverGetPointingTo                    ,+++-- ** popoverGetPosition+    popoverGetPosition                      ,+++-- ** popoverGetRelativeTo+    popoverGetRelativeTo                    ,+++-- ** popoverGetTransitionsEnabled+    popoverGetTransitionsEnabled            ,+++-- ** popoverNew+    popoverNew                              ,+++-- ** popoverNewFromModel+    popoverNewFromModel                     ,+++-- ** popoverSetDefaultWidget+    popoverSetDefaultWidget                 ,+++-- ** popoverSetModal+    popoverSetModal                         ,+++-- ** popoverSetPointingTo+    popoverSetPointingTo                    ,+++-- ** popoverSetPosition+    popoverSetPosition                      ,+++-- ** popoverSetRelativeTo+    popoverSetRelativeTo                    ,+++-- ** popoverSetTransitionsEnabled+    popoverSetTransitionsEnabled            ,+++++ -- * Properties+-- ** Modal+    PopoverModalPropertyInfo                ,+    constructPopoverModal                   ,+    getPopoverModal                         ,+    setPopoverModal                         ,+++-- ** PointingTo+    PopoverPointingToPropertyInfo           ,+    constructPopoverPointingTo              ,+    getPopoverPointingTo                    ,+    setPopoverPointingTo                    ,+++-- ** Position+    PopoverPositionPropertyInfo             ,+    constructPopoverPosition                ,+    getPopoverPosition                      ,+    setPopoverPosition                      ,+++-- ** RelativeTo+    PopoverRelativeToPropertyInfo           ,+    constructPopoverRelativeTo              ,+    getPopoverRelativeTo                    ,+    setPopoverRelativeTo                    ,+++-- ** TransitionsEnabled+    PopoverTransitionsEnabledPropertyInfo   ,+    constructPopoverTransitionsEnabled      ,+    getPopoverTransitionsEnabled            ,+    setPopoverTransitionsEnabled            ,+++++ -- * Signals+-- ** Closed+    PopoverClosedCallback                   ,+    PopoverClosedCallbackC                  ,+    PopoverClosedSignalInfo                 ,+    afterPopoverClosed                      ,+    mkPopoverClosedCallback                 ,+    noPopoverClosedCallback                 ,+    onPopoverClosed                         ,+    popoverClosedCallbackWrapper            ,+    popoverClosedClosure                    ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk+import qualified GI.Gio as Gio++newtype Popover = Popover (ForeignPtr Popover)+foreign import ccall "gtk_popover_get_type"+    c_gtk_popover_get_type :: IO GType++type instance ParentTypes Popover = PopoverParentTypes+type PopoverParentTypes = '[Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject Popover where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_popover_get_type+    ++class GObject o => PopoverK o+instance (GObject o, IsDescendantOf Popover o) => PopoverK o++toPopover :: PopoverK o => o -> IO Popover+toPopover = unsafeCastTo Popover++noPopover :: Maybe Popover+noPopover = Nothing++-- signal Popover::closed+type PopoverClosedCallback =+    IO ()++noPopoverClosedCallback :: Maybe PopoverClosedCallback+noPopoverClosedCallback = Nothing++type PopoverClosedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPopoverClosedCallback :: PopoverClosedCallbackC -> IO (FunPtr PopoverClosedCallbackC)++popoverClosedClosure :: PopoverClosedCallback -> IO Closure+popoverClosedClosure cb = newCClosure =<< mkPopoverClosedCallback wrapped+    where wrapped = popoverClosedCallbackWrapper cb++popoverClosedCallbackWrapper ::+    PopoverClosedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+popoverClosedCallbackWrapper _cb _ _ = do+    _cb ++onPopoverClosed :: (GObject a, MonadIO m) => a -> PopoverClosedCallback -> m SignalHandlerId+onPopoverClosed obj cb = liftIO $ connectPopoverClosed obj cb SignalConnectBefore+afterPopoverClosed :: (GObject a, MonadIO m) => a -> PopoverClosedCallback -> m SignalHandlerId+afterPopoverClosed obj cb = connectPopoverClosed obj cb SignalConnectAfter++connectPopoverClosed :: (GObject a, MonadIO m) =>+                        a -> PopoverClosedCallback -> SignalConnectMode -> m SignalHandlerId+connectPopoverClosed obj cb after = liftIO $ do+    cb' <- mkPopoverClosedCallback (popoverClosedCallbackWrapper cb)+    connectSignalFunPtr obj "closed" cb' after++-- VVV Prop "modal"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPopoverModal :: (MonadIO m, PopoverK o) => o -> m Bool+getPopoverModal obj = liftIO $ getObjectPropertyBool obj "modal"++setPopoverModal :: (MonadIO m, PopoverK o) => o -> Bool -> m ()+setPopoverModal obj val = liftIO $ setObjectPropertyBool obj "modal" val++constructPopoverModal :: Bool -> IO ([Char], GValue)+constructPopoverModal val = constructObjectPropertyBool "modal" val++data PopoverModalPropertyInfo+instance AttrInfo PopoverModalPropertyInfo where+    type AttrAllowedOps PopoverModalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverModalPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PopoverModalPropertyInfo = PopoverK+    type AttrGetType PopoverModalPropertyInfo = Bool+    type AttrLabel PopoverModalPropertyInfo = "Popover::modal"+    attrGet _ = getPopoverModal+    attrSet _ = setPopoverModal+    attrConstruct _ = constructPopoverModal++-- VVV Prop "pointing-to"+   -- Type: TInterface "Gdk" "Rectangle"+   -- Flags: [PropertyReadable,PropertyWritable]++getPopoverPointingTo :: (MonadIO m, PopoverK o) => o -> m Gdk.Rectangle+getPopoverPointingTo obj = liftIO $ getObjectPropertyBoxed obj "pointing-to" Gdk.Rectangle++setPopoverPointingTo :: (MonadIO m, PopoverK o) => o -> Gdk.Rectangle -> m ()+setPopoverPointingTo obj val = liftIO $ setObjectPropertyBoxed obj "pointing-to" val++constructPopoverPointingTo :: Gdk.Rectangle -> IO ([Char], GValue)+constructPopoverPointingTo val = constructObjectPropertyBoxed "pointing-to" val++data PopoverPointingToPropertyInfo+instance AttrInfo PopoverPointingToPropertyInfo where+    type AttrAllowedOps PopoverPointingToPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverPointingToPropertyInfo = (~) Gdk.Rectangle+    type AttrBaseTypeConstraint PopoverPointingToPropertyInfo = PopoverK+    type AttrGetType PopoverPointingToPropertyInfo = Gdk.Rectangle+    type AttrLabel PopoverPointingToPropertyInfo = "Popover::pointing-to"+    attrGet _ = getPopoverPointingTo+    attrSet _ = setPopoverPointingTo+    attrConstruct _ = constructPopoverPointingTo++-- VVV Prop "position"+   -- Type: TInterface "Gtk" "PositionType"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getPopoverPosition :: (MonadIO m, PopoverK o) => o -> m PositionType+getPopoverPosition obj = liftIO $ getObjectPropertyEnum obj "position"++setPopoverPosition :: (MonadIO m, PopoverK o) => o -> PositionType -> m ()+setPopoverPosition obj val = liftIO $ setObjectPropertyEnum obj "position" val++constructPopoverPosition :: PositionType -> IO ([Char], GValue)+constructPopoverPosition val = constructObjectPropertyEnum "position" val++data PopoverPositionPropertyInfo+instance AttrInfo PopoverPositionPropertyInfo where+    type AttrAllowedOps PopoverPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverPositionPropertyInfo = (~) PositionType+    type AttrBaseTypeConstraint PopoverPositionPropertyInfo = PopoverK+    type AttrGetType PopoverPositionPropertyInfo = PositionType+    type AttrLabel PopoverPositionPropertyInfo = "Popover::position"+    attrGet _ = getPopoverPosition+    attrSet _ = setPopoverPosition+    attrConstruct _ = constructPopoverPosition++-- VVV Prop "relative-to"+   -- Type: TInterface "Gtk" "Widget"+   -- Flags: [PropertyReadable,PropertyWritable]++getPopoverRelativeTo :: (MonadIO m, PopoverK o) => o -> m Widget+getPopoverRelativeTo obj = liftIO $ getObjectPropertyObject obj "relative-to" Widget++setPopoverRelativeTo :: (MonadIO m, PopoverK o, WidgetK a) => o -> a -> m ()+setPopoverRelativeTo obj val = liftIO $ setObjectPropertyObject obj "relative-to" val++constructPopoverRelativeTo :: (WidgetK a) => a -> IO ([Char], GValue)+constructPopoverRelativeTo val = constructObjectPropertyObject "relative-to" val++data PopoverRelativeToPropertyInfo+instance AttrInfo PopoverRelativeToPropertyInfo where+    type AttrAllowedOps PopoverRelativeToPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverRelativeToPropertyInfo = WidgetK+    type AttrBaseTypeConstraint PopoverRelativeToPropertyInfo = PopoverK+    type AttrGetType PopoverRelativeToPropertyInfo = Widget+    type AttrLabel PopoverRelativeToPropertyInfo = "Popover::relative-to"+    attrGet _ = getPopoverRelativeTo+    attrSet _ = setPopoverRelativeTo+    attrConstruct _ = constructPopoverRelativeTo++-- VVV Prop "transitions-enabled"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPopoverTransitionsEnabled :: (MonadIO m, PopoverK o) => o -> m Bool+getPopoverTransitionsEnabled obj = liftIO $ getObjectPropertyBool obj "transitions-enabled"++setPopoverTransitionsEnabled :: (MonadIO m, PopoverK o) => o -> Bool -> m ()+setPopoverTransitionsEnabled obj val = liftIO $ setObjectPropertyBool obj "transitions-enabled" val++constructPopoverTransitionsEnabled :: Bool -> IO ([Char], GValue)+constructPopoverTransitionsEnabled val = constructObjectPropertyBool "transitions-enabled" val++data PopoverTransitionsEnabledPropertyInfo+instance AttrInfo PopoverTransitionsEnabledPropertyInfo where+    type AttrAllowedOps PopoverTransitionsEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverTransitionsEnabledPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PopoverTransitionsEnabledPropertyInfo = PopoverK+    type AttrGetType PopoverTransitionsEnabledPropertyInfo = Bool+    type AttrLabel PopoverTransitionsEnabledPropertyInfo = "Popover::transitions-enabled"+    attrGet _ = getPopoverTransitionsEnabled+    attrSet _ = setPopoverTransitionsEnabled+    attrConstruct _ = constructPopoverTransitionsEnabled++type instance AttributeList Popover = PopoverAttributeList+type PopoverAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("modal", PopoverModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pointing-to", PopoverPointingToPropertyInfo), '("position", PopoverPositionPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("relative-to", PopoverRelativeToPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transitions-enabled", PopoverTransitionsEnabledPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data PopoverClosedSignalInfo+instance SignalInfo PopoverClosedSignalInfo where+    type HaskellCallbackType PopoverClosedSignalInfo = PopoverClosedCallback+    connectSignal _ = connectPopoverClosed++type instance SignalList Popover = PopoverSignalList+type PopoverSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("closed", PopoverClosedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Popover::new+-- method type : Constructor+-- Args : [Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Popover"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_new" gtk_popover_new :: +    Ptr Widget ->                           -- relative_to : TInterface "Gtk" "Widget"+    IO (Ptr Popover)+++popoverNew ::+    (MonadIO m, WidgetK a) =>+    Maybe (a) ->                            -- relative_to+    m Popover+popoverNew relative_to = liftIO $ do+    maybeRelative_to <- case relative_to of+        Nothing -> return nullPtr+        Just jRelative_to -> do+            let jRelative_to' = unsafeManagedPtrCastPtr jRelative_to+            return jRelative_to'+    result <- gtk_popover_new maybeRelative_to+    checkUnexpectedReturnNULL "gtk_popover_new" result+    result' <- (newObject Popover) result+    whenJust relative_to touchManagedPtr+    return result'++-- method Popover::new_from_model+-- method type : Constructor+-- Args : [Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "model", argType = TInterface "Gio" "MenuModel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Popover"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_new_from_model" gtk_popover_new_from_model :: +    Ptr Widget ->                           -- relative_to : TInterface "Gtk" "Widget"+    Ptr Gio.MenuModel ->                    -- model : TInterface "Gio" "MenuModel"+    IO (Ptr Popover)+++popoverNewFromModel ::+    (MonadIO m, WidgetK a, Gio.MenuModelK b) =>+    Maybe (a) ->                            -- relative_to+    b ->                                    -- model+    m Popover+popoverNewFromModel relative_to model = liftIO $ do+    maybeRelative_to <- case relative_to of+        Nothing -> return nullPtr+        Just jRelative_to -> do+            let jRelative_to' = unsafeManagedPtrCastPtr jRelative_to+            return jRelative_to'+    let model' = unsafeManagedPtrCastPtr model+    result <- gtk_popover_new_from_model maybeRelative_to model'+    checkUnexpectedReturnNULL "gtk_popover_new_from_model" result+    result' <- (newObject Popover) result+    whenJust relative_to touchManagedPtr+    touchManagedPtr model+    return result'++-- method Popover::bind_model+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", 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},Arg {argName = "action_namespace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", 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},Arg {argName = "action_namespace", 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 "gtk_popover_bind_model" gtk_popover_bind_model :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    Ptr Gio.MenuModel ->                    -- model : TInterface "Gio" "MenuModel"+    CString ->                              -- action_namespace : TBasicType TUTF8+    IO ()+++popoverBindModel ::+    (MonadIO m, PopoverK a, Gio.MenuModelK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- model+    Maybe (T.Text) ->                       -- action_namespace+    m ()+popoverBindModel _obj model action_namespace = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeModel <- case model of+        Nothing -> return nullPtr+        Just jModel -> do+            let jModel' = unsafeManagedPtrCastPtr jModel+            return jModel'+    maybeAction_namespace <- case action_namespace of+        Nothing -> return nullPtr+        Just jAction_namespace -> do+            jAction_namespace' <- textToCString jAction_namespace+            return jAction_namespace'+    gtk_popover_bind_model _obj' maybeModel maybeAction_namespace+    touchManagedPtr _obj+    whenJust model touchManagedPtr+    freeMem maybeAction_namespace+    return ()++-- method Popover::get_default_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_default_widget" gtk_popover_get_default_widget :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    IO (Ptr Widget)+++popoverGetDefaultWidget ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m Widget+popoverGetDefaultWidget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_popover_get_default_widget _obj'+    checkUnexpectedReturnNULL "gtk_popover_get_default_widget" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Popover::get_modal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_modal" gtk_popover_get_modal :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    IO CInt+++popoverGetModal ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m Bool+popoverGetModal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_popover_get_modal _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Popover::get_pointing_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_pointing_to" gtk_popover_get_pointing_to :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO CInt+++popoverGetPointingTo ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m (Bool,Gdk.Rectangle)+popoverGetPointingTo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    result <- gtk_popover_get_pointing_to _obj' rect+    let result' = (/= 0) result+    rect' <- (wrapBoxed Gdk.Rectangle) rect+    touchManagedPtr _obj+    return (result', rect')++-- method Popover::get_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PositionType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_position" gtk_popover_get_position :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    IO CUInt+++popoverGetPosition ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m PositionType+popoverGetPosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_popover_get_position _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Popover::get_relative_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Widget"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_relative_to" gtk_popover_get_relative_to :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    IO (Ptr Widget)+++popoverGetRelativeTo ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m Widget+popoverGetRelativeTo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_popover_get_relative_to _obj'+    checkUnexpectedReturnNULL "gtk_popover_get_relative_to" result+    result' <- (newObject Widget) result+    touchManagedPtr _obj+    return result'++-- method Popover::get_transitions_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_get_transitions_enabled" gtk_popover_get_transitions_enabled :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    IO CInt+++popoverGetTransitionsEnabled ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    m Bool+popoverGetTransitionsEnabled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_popover_get_transitions_enabled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Popover::set_default_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "widget", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_set_default_widget" gtk_popover_set_default_widget :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    Ptr Widget ->                           -- widget : TInterface "Gtk" "Widget"+    IO ()+++popoverSetDefaultWidget ::+    (MonadIO m, PopoverK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- widget+    m ()+popoverSetDefaultWidget _obj widget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeWidget <- case widget of+        Nothing -> return nullPtr+        Just jWidget -> do+            let jWidget' = unsafeManagedPtrCastPtr jWidget+            return jWidget'+    gtk_popover_set_default_widget _obj' maybeWidget+    touchManagedPtr _obj+    whenJust widget touchManagedPtr+    return ()++-- method Popover::set_modal+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modal", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "modal", 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 "gtk_popover_set_modal" gtk_popover_set_modal :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    CInt ->                                 -- modal : TBasicType TBoolean+    IO ()+++popoverSetModal ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- modal+    m ()+popoverSetModal _obj modal = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let modal' = (fromIntegral . fromEnum) modal+    gtk_popover_set_modal _obj' modal'+    touchManagedPtr _obj+    return ()++-- method Popover::set_pointing_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_set_pointing_to" gtk_popover_set_pointing_to :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    Ptr Gdk.Rectangle ->                    -- rect : TInterface "Gdk" "Rectangle"+    IO ()+++popoverSetPointingTo ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    Gdk.Rectangle ->                        -- rect+    m ()+popoverSetPointingTo _obj rect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let rect' = unsafeManagedPtrGetPtr rect+    gtk_popover_set_pointing_to _obj' rect'+    touchManagedPtr _obj+    touchManagedPtr rect+    return ()++-- method Popover::set_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "position", argType = TInterface "Gtk" "PositionType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_set_position" gtk_popover_set_position :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    CUInt ->                                -- position : TInterface "Gtk" "PositionType"+    IO ()+++popoverSetPosition ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    PositionType ->                         -- position+    m ()+popoverSetPosition _obj position = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let position' = (fromIntegral . fromEnum) position+    gtk_popover_set_position _obj' position'+    touchManagedPtr _obj+    return ()++-- method Popover::set_relative_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "relative_to", argType = TInterface "Gtk" "Widget", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_set_relative_to" gtk_popover_set_relative_to :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    Ptr Widget ->                           -- relative_to : TInterface "Gtk" "Widget"+    IO ()+++popoverSetRelativeTo ::+    (MonadIO m, PopoverK a, WidgetK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- relative_to+    m ()+popoverSetRelativeTo _obj relative_to = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeRelative_to <- case relative_to of+        Nothing -> return nullPtr+        Just jRelative_to -> do+            let jRelative_to' = unsafeManagedPtrCastPtr jRelative_to+            return jRelative_to'+    gtk_popover_set_relative_to _obj' maybeRelative_to+    touchManagedPtr _obj+    whenJust relative_to touchManagedPtr+    return ()++-- method Popover::set_transitions_enabled+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "transitions_enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Popover", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "transitions_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 "gtk_popover_set_transitions_enabled" gtk_popover_set_transitions_enabled :: +    Ptr Popover ->                          -- _obj : TInterface "Gtk" "Popover"+    CInt ->                                 -- transitions_enabled : TBasicType TBoolean+    IO ()+++popoverSetTransitionsEnabled ::+    (MonadIO m, PopoverK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- transitions_enabled+    m ()+popoverSetTransitionsEnabled _obj transitions_enabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let transitions_enabled' = (fromIntegral . fromEnum) transitions_enabled+    gtk_popover_set_transitions_enabled _obj' transitions_enabled'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Popover.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.Popover where++import Prelude ()+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 Popover = Popover (ForeignPtr Popover)+instance GObject Popover where+class GObject o => PopoverK o+instance (GObject o, IsDescendantOf Popover o) => PopoverK o+data PopoverModalPropertyInfo+data PopoverPointingToPropertyInfo+data PopoverPositionPropertyInfo+data PopoverRelativeToPropertyInfo+data PopoverTransitionsEnabledPropertyInfo+data PopoverClosedSignalInfo
+ GI/Gtk/Objects/PopoverAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.PopoverAccessible+    ( ++-- * Exported types+    PopoverAccessible(..)                   ,+    PopoverAccessibleK                      ,+    toPopoverAccessible                     ,+    noPopoverAccessible                     ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype PopoverAccessible = PopoverAccessible (ForeignPtr PopoverAccessible)+foreign import ccall "gtk_popover_accessible_get_type"+    c_gtk_popover_accessible_get_type :: IO GType++type instance ParentTypes PopoverAccessible = PopoverAccessibleParentTypes+type PopoverAccessibleParentTypes = '[ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component]++instance GObject PopoverAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_popover_accessible_get_type+    ++class GObject o => PopoverAccessibleK o+instance (GObject o, IsDescendantOf PopoverAccessible o) => PopoverAccessibleK o++toPopoverAccessible :: PopoverAccessibleK o => o -> IO PopoverAccessible+toPopoverAccessible = unsafeCastTo PopoverAccessible++noPopoverAccessible :: Maybe PopoverAccessible+noPopoverAccessible = Nothing++type instance AttributeList PopoverAccessible = PopoverAccessibleAttributeList+type PopoverAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList PopoverAccessible = PopoverAccessibleSignalList+type PopoverAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/PopoverAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.PopoverAccessible where++import Prelude ()+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 PopoverAccessible = PopoverAccessible (ForeignPtr PopoverAccessible)+instance GObject PopoverAccessible where+class GObject o => PopoverAccessibleK o+instance (GObject o, IsDescendantOf PopoverAccessible o) => PopoverAccessibleK o
+ GI/Gtk/Objects/PopoverMenu.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)+-}++module GI.Gtk.Objects.PopoverMenu+    ( ++-- * Exported types+    PopoverMenu(..)                         ,+    PopoverMenuK                            ,+    toPopoverMenu                           ,+    noPopoverMenu                           ,+++ -- * Methods+-- ** popoverMenuNew+    popoverMenuNew                          ,+++-- ** popoverMenuOpenSubmenu+    popoverMenuOpenSubmenu                  ,+++++ -- * Properties+-- ** VisibleSubmenu+    PopoverMenuVisibleSubmenuPropertyInfo   ,+    constructPopoverMenuVisibleSubmenu      ,+    getPopoverMenuVisibleSubmenu            ,+    setPopoverMenuVisibleSubmenu            ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype PopoverMenu = PopoverMenu (ForeignPtr PopoverMenu)+foreign import ccall "gtk_popover_menu_get_type"+    c_gtk_popover_menu_get_type :: IO GType++type instance ParentTypes PopoverMenu = PopoverMenuParentTypes+type PopoverMenuParentTypes = '[Popover, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Buildable]++instance GObject PopoverMenu where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_popover_menu_get_type+    ++class GObject o => PopoverMenuK o+instance (GObject o, IsDescendantOf PopoverMenu o) => PopoverMenuK o++toPopoverMenu :: PopoverMenuK o => o -> IO PopoverMenu+toPopoverMenu = unsafeCastTo PopoverMenu++noPopoverMenu :: Maybe PopoverMenu+noPopoverMenu = Nothing++-- VVV Prop "visible-submenu"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getPopoverMenuVisibleSubmenu :: (MonadIO m, PopoverMenuK o) => o -> m T.Text+getPopoverMenuVisibleSubmenu obj = liftIO $ getObjectPropertyString obj "visible-submenu"++setPopoverMenuVisibleSubmenu :: (MonadIO m, PopoverMenuK o) => o -> T.Text -> m ()+setPopoverMenuVisibleSubmenu obj val = liftIO $ setObjectPropertyString obj "visible-submenu" val++constructPopoverMenuVisibleSubmenu :: T.Text -> IO ([Char], GValue)+constructPopoverMenuVisibleSubmenu val = constructObjectPropertyString "visible-submenu" val++data PopoverMenuVisibleSubmenuPropertyInfo+instance AttrInfo PopoverMenuVisibleSubmenuPropertyInfo where+    type AttrAllowedOps PopoverMenuVisibleSubmenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PopoverMenuVisibleSubmenuPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PopoverMenuVisibleSubmenuPropertyInfo = PopoverMenuK+    type AttrGetType PopoverMenuVisibleSubmenuPropertyInfo = T.Text+    type AttrLabel PopoverMenuVisibleSubmenuPropertyInfo = "PopoverMenu::visible-submenu"+    attrGet _ = getPopoverMenuVisibleSubmenu+    attrSet _ = setPopoverMenuVisibleSubmenu+    attrConstruct _ = constructPopoverMenuVisibleSubmenu++type instance AttributeList PopoverMenu = PopoverMenuAttributeList+type PopoverMenuAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("modal", PopoverModalPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pointing-to", PopoverPointingToPropertyInfo), '("position", PopoverPositionPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("relative-to", PopoverRelativeToPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("transitions-enabled", PopoverTransitionsEnabledPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("visible-submenu", PopoverMenuVisibleSubmenuPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList PopoverMenu = PopoverMenuSignalList+type PopoverMenuSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("closed", PopoverClosedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PopoverMenu::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "PopoverMenu"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_popover_menu_new" gtk_popover_menu_new :: +    IO (Ptr PopoverMenu)+++popoverMenuNew ::+    (MonadIO m) =>+    m PopoverMenu+popoverMenuNew  = liftIO $ do+    result <- gtk_popover_menu_new+    checkUnexpectedReturnNULL "gtk_popover_menu_new" result+    result' <- (newObject PopoverMenu) result+    return result'++-- method PopoverMenu::open_submenu+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PopoverMenu", 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 "Gtk" "PopoverMenu", 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 "gtk_popover_menu_open_submenu" gtk_popover_menu_open_submenu :: +    Ptr PopoverMenu ->                      -- _obj : TInterface "Gtk" "PopoverMenu"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++popoverMenuOpenSubmenu ::+    (MonadIO m, PopoverMenuK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- name+    m ()+popoverMenuOpenSubmenu _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gtk_popover_menu_open_submenu _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++
+ GI/Gtk/Objects/PopoverMenu.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.PopoverMenu where++import Prelude ()+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 PopoverMenu = PopoverMenu (ForeignPtr PopoverMenu)+instance GObject PopoverMenu where+class GObject o => PopoverMenuK o+instance (GObject o, IsDescendantOf PopoverMenu o) => PopoverMenuK o+data PopoverMenuVisibleSubmenuPropertyInfo
+ GI/Gtk/Objects/PrintContext.hs view
@@ -0,0 +1,416 @@++{- |+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.Gtk.Objects.PrintContext+    ( ++-- * Exported types+    PrintContext(..)                        ,+    PrintContextK                           ,+    toPrintContext                          ,+    noPrintContext                          ,+++ -- * Methods+-- ** printContextCreatePangoContext+    printContextCreatePangoContext          ,+++-- ** printContextCreatePangoLayout+    printContextCreatePangoLayout           ,+++-- ** printContextGetCairoContext+    printContextGetCairoContext             ,+++-- ** printContextGetDpiX+    printContextGetDpiX                     ,+++-- ** printContextGetDpiY+    printContextGetDpiY                     ,+++-- ** printContextGetHardMargins+    printContextGetHardMargins              ,+++-- ** printContextGetHeight+    printContextGetHeight                   ,+++-- ** printContextGetPageSetup+    printContextGetPageSetup                ,+++-- ** printContextGetPangoFontmap+    printContextGetPangoFontmap             ,+++-- ** printContextGetWidth+    printContextGetWidth                    ,+++-- ** printContextSetCairoContext+    printContextSetCairoContext             ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango+import qualified GI.Cairo as Cairo++newtype PrintContext = PrintContext (ForeignPtr PrintContext)+foreign import ccall "gtk_print_context_get_type"+    c_gtk_print_context_get_type :: IO GType++type instance ParentTypes PrintContext = PrintContextParentTypes+type PrintContextParentTypes = '[GObject.Object]++instance GObject PrintContext where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_print_context_get_type+    ++class GObject o => PrintContextK o+instance (GObject o, IsDescendantOf PrintContext o) => PrintContextK o++toPrintContext :: PrintContextK o => o -> IO PrintContext+toPrintContext = unsafeCastTo PrintContext++noPrintContext :: Maybe PrintContext+noPrintContext = Nothing++type instance AttributeList PrintContext = PrintContextAttributeList+type PrintContextAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PrintContext = PrintContextSignalList+type PrintContextSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PrintContext::create_pango_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "Context"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_create_pango_context" gtk_print_context_create_pango_context :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO (Ptr Pango.Context)+++printContextCreatePangoContext ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Pango.Context+printContextCreatePangoContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_create_pango_context _obj'+    checkUnexpectedReturnNULL "gtk_print_context_create_pango_context" result+    result' <- (wrapObject Pango.Context) result+    touchManagedPtr _obj+    return result'++-- method PrintContext::create_pango_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "Layout"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_create_pango_layout" gtk_print_context_create_pango_layout :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO (Ptr Pango.Layout)+++printContextCreatePangoLayout ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Pango.Layout+printContextCreatePangoLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_create_pango_layout _obj'+    checkUnexpectedReturnNULL "gtk_print_context_create_pango_layout" result+    result' <- (wrapObject Pango.Layout) result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_cairo_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Context"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_cairo_context" gtk_print_context_get_cairo_context :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO (Ptr Cairo.Context)+++printContextGetCairoContext ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Cairo.Context+printContextGetCairoContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_cairo_context _obj'+    checkUnexpectedReturnNULL "gtk_print_context_get_cairo_context" result+    result' <- (newBoxed Cairo.Context) result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_dpi_x+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_dpi_x" gtk_print_context_get_dpi_x :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO CDouble+++printContextGetDpiX ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Double+printContextGetDpiX _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_dpi_x _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_dpi_y+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_dpi_y" gtk_print_context_get_dpi_y :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO CDouble+++printContextGetDpiY ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Double+printContextGetDpiY _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_dpi_y _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_hard_margins+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "top", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "bottom", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "left", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "right", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_hard_margins" gtk_print_context_get_hard_margins :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    Ptr CDouble ->                          -- top : TBasicType TDouble+    Ptr CDouble ->                          -- bottom : TBasicType TDouble+    Ptr CDouble ->                          -- left : TBasicType TDouble+    Ptr CDouble ->                          -- right : TBasicType TDouble+    IO CInt+++printContextGetHardMargins ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m (Bool,Double,Double,Double,Double)+printContextGetHardMargins _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    top <- allocMem :: IO (Ptr CDouble)+    bottom <- allocMem :: IO (Ptr CDouble)+    left <- allocMem :: IO (Ptr CDouble)+    right <- allocMem :: IO (Ptr CDouble)+    result <- gtk_print_context_get_hard_margins _obj' top bottom left right+    let result' = (/= 0) result+    top' <- peek top+    let top'' = realToFrac top'+    bottom' <- peek bottom+    let bottom'' = realToFrac bottom'+    left' <- peek left+    let left'' = realToFrac left'+    right' <- peek right+    let right'' = realToFrac right'+    touchManagedPtr _obj+    freeMem top+    freeMem bottom+    freeMem left+    freeMem right+    return (result', top'', bottom'', left'', right'')++-- method PrintContext::get_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_height" gtk_print_context_get_height :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO CDouble+++printContextGetHeight ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Double+printContextGetHeight _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_height _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_page_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_page_setup" gtk_print_context_get_page_setup :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO (Ptr PageSetup)+++printContextGetPageSetup ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m PageSetup+printContextGetPageSetup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_page_setup _obj'+    checkUnexpectedReturnNULL "gtk_print_context_get_page_setup" result+    result' <- (newObject PageSetup) result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_pango_fontmap+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "FontMap"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_pango_fontmap" gtk_print_context_get_pango_fontmap :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO (Ptr Pango.FontMap)+++printContextGetPangoFontmap ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Pango.FontMap+printContextGetPangoFontmap _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_pango_fontmap _obj'+    checkUnexpectedReturnNULL "gtk_print_context_get_pango_fontmap" result+    result' <- (newObject Pango.FontMap) result+    touchManagedPtr _obj+    return result'++-- method PrintContext::get_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_get_width" gtk_print_context_get_width :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    IO CDouble+++printContextGetWidth ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    m Double+printContextGetWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_context_get_width _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintContext::set_cairo_context+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dpi_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dpi_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cr", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dpi_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dpi_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_context_set_cairo_context" gtk_print_context_set_cairo_context :: +    Ptr PrintContext ->                     -- _obj : TInterface "Gtk" "PrintContext"+    Ptr Cairo.Context ->                    -- cr : TInterface "cairo" "Context"+    CDouble ->                              -- dpi_x : TBasicType TDouble+    CDouble ->                              -- dpi_y : TBasicType TDouble+    IO ()+++printContextSetCairoContext ::+    (MonadIO m, PrintContextK a) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cr+    Double ->                               -- dpi_x+    Double ->                               -- dpi_y+    m ()+printContextSetCairoContext _obj cr dpi_x dpi_y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cr' = unsafeManagedPtrGetPtr cr+    let dpi_x' = realToFrac dpi_x+    let dpi_y' = realToFrac dpi_y+    gtk_print_context_set_cairo_context _obj' cr' dpi_x' dpi_y'+    touchManagedPtr _obj+    touchManagedPtr cr+    return ()++
+ GI/Gtk/Objects/PrintContext.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.PrintContext where++import Prelude ()+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 PrintContext = PrintContext (ForeignPtr PrintContext)+instance GObject PrintContext where+class GObject o => PrintContextK o+instance (GObject o, IsDescendantOf PrintContext o) => PrintContextK o
+ GI/Gtk/Objects/PrintOperation.hs view
@@ -0,0 +1,2210 @@++{- |+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.Gtk.Objects.PrintOperation+    ( ++-- * Exported types+    PrintOperation(..)                      ,+    PrintOperationK                         ,+    toPrintOperation                        ,+    noPrintOperation                        ,+++ -- * Methods+-- ** printOperationCancel+    printOperationCancel                    ,+++-- ** printOperationDrawPageFinish+    printOperationDrawPageFinish            ,+++-- ** printOperationGetDefaultPageSetup+    printOperationGetDefaultPageSetup       ,+++-- ** printOperationGetEmbedPageSetup+    printOperationGetEmbedPageSetup         ,+++-- ** printOperationGetError+    printOperationGetError                  ,+++-- ** printOperationGetHasSelection+    printOperationGetHasSelection           ,+++-- ** printOperationGetNPagesToPrint+    printOperationGetNPagesToPrint          ,+++-- ** printOperationGetPrintSettings+    printOperationGetPrintSettings          ,+++-- ** printOperationGetStatus+    printOperationGetStatus                 ,+++-- ** printOperationGetStatusString+    printOperationGetStatusString           ,+++-- ** printOperationGetSupportSelection+    printOperationGetSupportSelection       ,+++-- ** printOperationIsFinished+    printOperationIsFinished                ,+++-- ** printOperationNew+    printOperationNew                       ,+++-- ** printOperationRun+    printOperationRun                       ,+++-- ** printOperationSetAllowAsync+    printOperationSetAllowAsync             ,+++-- ** printOperationSetCurrentPage+    printOperationSetCurrentPage            ,+++-- ** printOperationSetCustomTabLabel+    printOperationSetCustomTabLabel         ,+++-- ** printOperationSetDefaultPageSetup+    printOperationSetDefaultPageSetup       ,+++-- ** printOperationSetDeferDrawing+    printOperationSetDeferDrawing           ,+++-- ** printOperationSetEmbedPageSetup+    printOperationSetEmbedPageSetup         ,+++-- ** printOperationSetExportFilename+    printOperationSetExportFilename         ,+++-- ** printOperationSetHasSelection+    printOperationSetHasSelection           ,+++-- ** printOperationSetJobName+    printOperationSetJobName                ,+++-- ** printOperationSetNPages+    printOperationSetNPages                 ,+++-- ** printOperationSetPrintSettings+    printOperationSetPrintSettings          ,+++-- ** printOperationSetShowProgress+    printOperationSetShowProgress           ,+++-- ** printOperationSetSupportSelection+    printOperationSetSupportSelection       ,+++-- ** printOperationSetTrackPrintStatus+    printOperationSetTrackPrintStatus       ,+++-- ** printOperationSetUnit+    printOperationSetUnit                   ,+++-- ** printOperationSetUseFullPage+    printOperationSetUseFullPage            ,+++++ -- * Properties+-- ** AllowAsync+    PrintOperationAllowAsyncPropertyInfo    ,+    constructPrintOperationAllowAsync       ,+    getPrintOperationAllowAsync             ,+    setPrintOperationAllowAsync             ,+++-- ** CurrentPage+    PrintOperationCurrentPagePropertyInfo   ,+    constructPrintOperationCurrentPage      ,+    getPrintOperationCurrentPage            ,+    setPrintOperationCurrentPage            ,+++-- ** CustomTabLabel+    PrintOperationCustomTabLabelPropertyInfo,+    constructPrintOperationCustomTabLabel   ,+    getPrintOperationCustomTabLabel         ,+    setPrintOperationCustomTabLabel         ,+++-- ** DefaultPageSetup+    PrintOperationDefaultPageSetupPropertyInfo,+    constructPrintOperationDefaultPageSetup ,+    getPrintOperationDefaultPageSetup       ,+    setPrintOperationDefaultPageSetup       ,+++-- ** EmbedPageSetup+    PrintOperationEmbedPageSetupPropertyInfo,+    constructPrintOperationEmbedPageSetup   ,+    getPrintOperationEmbedPageSetup         ,+    setPrintOperationEmbedPageSetup         ,+++-- ** ExportFilename+    PrintOperationExportFilenamePropertyInfo,+    constructPrintOperationExportFilename   ,+    getPrintOperationExportFilename         ,+    setPrintOperationExportFilename         ,+++-- ** HasSelection+    PrintOperationHasSelectionPropertyInfo  ,+    constructPrintOperationHasSelection     ,+    getPrintOperationHasSelection           ,+    setPrintOperationHasSelection           ,+++-- ** JobName+    PrintOperationJobNamePropertyInfo       ,+    constructPrintOperationJobName          ,+    getPrintOperationJobName                ,+    setPrintOperationJobName                ,+++-- ** NPages+    PrintOperationNPagesPropertyInfo        ,+    constructPrintOperationNPages           ,+    getPrintOperationNPages                 ,+    setPrintOperationNPages                 ,+++-- ** NPagesToPrint+    PrintOperationNPagesToPrintPropertyInfo ,+    getPrintOperationNPagesToPrint          ,+++-- ** PrintSettings+    PrintOperationPrintSettingsPropertyInfo ,+    constructPrintOperationPrintSettings    ,+    getPrintOperationPrintSettings          ,+    setPrintOperationPrintSettings          ,+++-- ** ShowProgress+    PrintOperationShowProgressPropertyInfo  ,+    constructPrintOperationShowProgress     ,+    getPrintOperationShowProgress           ,+    setPrintOperationShowProgress           ,+++-- ** Status+    PrintOperationStatusPropertyInfo        ,+    getPrintOperationStatus                 ,+++-- ** StatusString+    PrintOperationStatusStringPropertyInfo  ,+    getPrintOperationStatusString           ,+++-- ** SupportSelection+    PrintOperationSupportSelectionPropertyInfo,+    constructPrintOperationSupportSelection ,+    getPrintOperationSupportSelection       ,+    setPrintOperationSupportSelection       ,+++-- ** TrackPrintStatus+    PrintOperationTrackPrintStatusPropertyInfo,+    constructPrintOperationTrackPrintStatus ,+    getPrintOperationTrackPrintStatus       ,+    setPrintOperationTrackPrintStatus       ,+++-- ** Unit+    PrintOperationUnitPropertyInfo          ,+    constructPrintOperationUnit             ,+    getPrintOperationUnit                   ,+    setPrintOperationUnit                   ,+++-- ** UseFullPage+    PrintOperationUseFullPagePropertyInfo   ,+    constructPrintOperationUseFullPage      ,+    getPrintOperationUseFullPage            ,+    setPrintOperationUseFullPage            ,+++++ -- * Signals+-- ** BeginPrint+    PrintOperationBeginPrintCallback        ,+    PrintOperationBeginPrintCallbackC       ,+    PrintOperationBeginPrintSignalInfo      ,+    afterPrintOperationBeginPrint           ,+    mkPrintOperationBeginPrintCallback      ,+    noPrintOperationBeginPrintCallback      ,+    onPrintOperationBeginPrint              ,+    printOperationBeginPrintCallbackWrapper ,+    printOperationBeginPrintClosure         ,+++-- ** CreateCustomWidget+    PrintOperationCreateCustomWidgetCallback,+    PrintOperationCreateCustomWidgetCallbackC,+    PrintOperationCreateCustomWidgetSignalInfo,+    afterPrintOperationCreateCustomWidget   ,+    mkPrintOperationCreateCustomWidgetCallback,+    noPrintOperationCreateCustomWidgetCallback,+    onPrintOperationCreateCustomWidget      ,+    printOperationCreateCustomWidgetCallbackWrapper,+    printOperationCreateCustomWidgetClosure ,+++-- ** CustomWidgetApply+    PrintOperationCustomWidgetApplyCallback ,+    PrintOperationCustomWidgetApplyCallbackC,+    PrintOperationCustomWidgetApplySignalInfo,+    afterPrintOperationCustomWidgetApply    ,+    mkPrintOperationCustomWidgetApplyCallback,+    noPrintOperationCustomWidgetApplyCallback,+    onPrintOperationCustomWidgetApply       ,+    printOperationCustomWidgetApplyCallbackWrapper,+    printOperationCustomWidgetApplyClosure  ,+++-- ** Done+    PrintOperationDoneCallback              ,+    PrintOperationDoneCallbackC             ,+    PrintOperationDoneSignalInfo            ,+    afterPrintOperationDone                 ,+    mkPrintOperationDoneCallback            ,+    noPrintOperationDoneCallback            ,+    onPrintOperationDone                    ,+    printOperationDoneCallbackWrapper       ,+    printOperationDoneClosure               ,+++-- ** DrawPage+    PrintOperationDrawPageCallback          ,+    PrintOperationDrawPageCallbackC         ,+    PrintOperationDrawPageSignalInfo        ,+    afterPrintOperationDrawPage             ,+    mkPrintOperationDrawPageCallback        ,+    noPrintOperationDrawPageCallback        ,+    onPrintOperationDrawPage                ,+    printOperationDrawPageCallbackWrapper   ,+    printOperationDrawPageClosure           ,+++-- ** EndPrint+    PrintOperationEndPrintCallback          ,+    PrintOperationEndPrintCallbackC         ,+    PrintOperationEndPrintSignalInfo        ,+    afterPrintOperationEndPrint             ,+    mkPrintOperationEndPrintCallback        ,+    noPrintOperationEndPrintCallback        ,+    onPrintOperationEndPrint                ,+    printOperationEndPrintCallbackWrapper   ,+    printOperationEndPrintClosure           ,+++-- ** Paginate+    PrintOperationPaginateCallback          ,+    PrintOperationPaginateCallbackC         ,+    PrintOperationPaginateSignalInfo        ,+    afterPrintOperationPaginate             ,+    mkPrintOperationPaginateCallback        ,+    noPrintOperationPaginateCallback        ,+    onPrintOperationPaginate                ,+    printOperationPaginateCallbackWrapper   ,+    printOperationPaginateClosure           ,+++-- ** Preview+    PrintOperationPreviewCallback           ,+    PrintOperationPreviewCallbackC          ,+    PrintOperationPreviewSignalInfo         ,+    afterPrintOperationPreview              ,+    mkPrintOperationPreviewCallback         ,+    noPrintOperationPreviewCallback         ,+    onPrintOperationPreview                 ,+    printOperationPreviewCallbackWrapper    ,+    printOperationPreviewClosure            ,+++-- ** RequestPageSetup+    PrintOperationRequestPageSetupCallback  ,+    PrintOperationRequestPageSetupCallbackC ,+    PrintOperationRequestPageSetupSignalInfo,+    afterPrintOperationRequestPageSetup     ,+    mkPrintOperationRequestPageSetupCallback,+    noPrintOperationRequestPageSetupCallback,+    onPrintOperationRequestPageSetup        ,+    printOperationRequestPageSetupCallbackWrapper,+    printOperationRequestPageSetupClosure   ,+++-- ** StatusChanged+    PrintOperationStatusChangedCallback     ,+    PrintOperationStatusChangedCallbackC    ,+    PrintOperationStatusChangedSignalInfo   ,+    afterPrintOperationStatusChanged        ,+    mkPrintOperationStatusChangedCallback   ,+    noPrintOperationStatusChangedCallback   ,+    onPrintOperationStatusChanged           ,+    printOperationStatusChangedCallbackWrapper,+    printOperationStatusChangedClosure      ,+++-- ** UpdateCustomWidget+    PrintOperationUpdateCustomWidgetCallback,+    PrintOperationUpdateCustomWidgetCallbackC,+    PrintOperationUpdateCustomWidgetSignalInfo,+    afterPrintOperationUpdateCustomWidget   ,+    mkPrintOperationUpdateCustomWidgetCallback,+    noPrintOperationUpdateCustomWidgetCallback,+    onPrintOperationUpdateCustomWidget      ,+    printOperationUpdateCustomWidgetCallbackWrapper,+    printOperationUpdateCustomWidgetClosure ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype PrintOperation = PrintOperation (ForeignPtr PrintOperation)+foreign import ccall "gtk_print_operation_get_type"+    c_gtk_print_operation_get_type :: IO GType++type instance ParentTypes PrintOperation = PrintOperationParentTypes+type PrintOperationParentTypes = '[GObject.Object, PrintOperationPreview]++instance GObject PrintOperation where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_print_operation_get_type+    ++class GObject o => PrintOperationK o+instance (GObject o, IsDescendantOf PrintOperation o) => PrintOperationK o++toPrintOperation :: PrintOperationK o => o -> IO PrintOperation+toPrintOperation = unsafeCastTo PrintOperation++noPrintOperation :: Maybe PrintOperation+noPrintOperation = Nothing++-- signal PrintOperation::begin-print+type PrintOperationBeginPrintCallback =+    PrintContext ->+    IO ()++noPrintOperationBeginPrintCallback :: Maybe PrintOperationBeginPrintCallback+noPrintOperationBeginPrintCallback = Nothing++type PrintOperationBeginPrintCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationBeginPrintCallback :: PrintOperationBeginPrintCallbackC -> IO (FunPtr PrintOperationBeginPrintCallbackC)++printOperationBeginPrintClosure :: PrintOperationBeginPrintCallback -> IO Closure+printOperationBeginPrintClosure cb = newCClosure =<< mkPrintOperationBeginPrintCallback wrapped+    where wrapped = printOperationBeginPrintCallbackWrapper cb++printOperationBeginPrintCallbackWrapper ::+    PrintOperationBeginPrintCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Ptr () ->+    IO ()+printOperationBeginPrintCallbackWrapper _cb _ context _ = do+    context' <- (newObject PrintContext) context+    _cb  context'++onPrintOperationBeginPrint :: (GObject a, MonadIO m) => a -> PrintOperationBeginPrintCallback -> m SignalHandlerId+onPrintOperationBeginPrint obj cb = liftIO $ connectPrintOperationBeginPrint obj cb SignalConnectBefore+afterPrintOperationBeginPrint :: (GObject a, MonadIO m) => a -> PrintOperationBeginPrintCallback -> m SignalHandlerId+afterPrintOperationBeginPrint obj cb = connectPrintOperationBeginPrint obj cb SignalConnectAfter++connectPrintOperationBeginPrint :: (GObject a, MonadIO m) =>+                                   a -> PrintOperationBeginPrintCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationBeginPrint obj cb after = liftIO $ do+    cb' <- mkPrintOperationBeginPrintCallback (printOperationBeginPrintCallbackWrapper cb)+    connectSignalFunPtr obj "begin-print" cb' after++-- signal PrintOperation::create-custom-widget+type PrintOperationCreateCustomWidgetCallback =+    IO GObject.Object++noPrintOperationCreateCustomWidgetCallback :: Maybe PrintOperationCreateCustomWidgetCallback+noPrintOperationCreateCustomWidgetCallback = Nothing++type PrintOperationCreateCustomWidgetCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO (Ptr GObject.Object)++foreign import ccall "wrapper"+    mkPrintOperationCreateCustomWidgetCallback :: PrintOperationCreateCustomWidgetCallbackC -> IO (FunPtr PrintOperationCreateCustomWidgetCallbackC)++printOperationCreateCustomWidgetClosure :: PrintOperationCreateCustomWidgetCallback -> IO Closure+printOperationCreateCustomWidgetClosure cb = newCClosure =<< mkPrintOperationCreateCustomWidgetCallback wrapped+    where wrapped = printOperationCreateCustomWidgetCallbackWrapper cb++printOperationCreateCustomWidgetCallbackWrapper ::+    PrintOperationCreateCustomWidgetCallback ->+    Ptr () ->+    Ptr () ->+    IO (Ptr GObject.Object)+printOperationCreateCustomWidgetCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = unsafeManagedPtrCastPtr result+    return result'++onPrintOperationCreateCustomWidget :: (GObject a, MonadIO m) => a -> PrintOperationCreateCustomWidgetCallback -> m SignalHandlerId+onPrintOperationCreateCustomWidget obj cb = liftIO $ connectPrintOperationCreateCustomWidget obj cb SignalConnectBefore+afterPrintOperationCreateCustomWidget :: (GObject a, MonadIO m) => a -> PrintOperationCreateCustomWidgetCallback -> m SignalHandlerId+afterPrintOperationCreateCustomWidget obj cb = connectPrintOperationCreateCustomWidget obj cb SignalConnectAfter++connectPrintOperationCreateCustomWidget :: (GObject a, MonadIO m) =>+                                           a -> PrintOperationCreateCustomWidgetCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationCreateCustomWidget obj cb after = liftIO $ do+    cb' <- mkPrintOperationCreateCustomWidgetCallback (printOperationCreateCustomWidgetCallbackWrapper cb)+    connectSignalFunPtr obj "create-custom-widget" cb' after++-- signal PrintOperation::custom-widget-apply+type PrintOperationCustomWidgetApplyCallback =+    Widget ->+    IO ()++noPrintOperationCustomWidgetApplyCallback :: Maybe PrintOperationCustomWidgetApplyCallback+noPrintOperationCustomWidgetApplyCallback = Nothing++type PrintOperationCustomWidgetApplyCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationCustomWidgetApplyCallback :: PrintOperationCustomWidgetApplyCallbackC -> IO (FunPtr PrintOperationCustomWidgetApplyCallbackC)++printOperationCustomWidgetApplyClosure :: PrintOperationCustomWidgetApplyCallback -> IO Closure+printOperationCustomWidgetApplyClosure cb = newCClosure =<< mkPrintOperationCustomWidgetApplyCallback wrapped+    where wrapped = printOperationCustomWidgetApplyCallbackWrapper cb++printOperationCustomWidgetApplyCallbackWrapper ::+    PrintOperationCustomWidgetApplyCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr () ->+    IO ()+printOperationCustomWidgetApplyCallbackWrapper _cb _ widget _ = do+    widget' <- (newObject Widget) widget+    _cb  widget'++onPrintOperationCustomWidgetApply :: (GObject a, MonadIO m) => a -> PrintOperationCustomWidgetApplyCallback -> m SignalHandlerId+onPrintOperationCustomWidgetApply obj cb = liftIO $ connectPrintOperationCustomWidgetApply obj cb SignalConnectBefore+afterPrintOperationCustomWidgetApply :: (GObject a, MonadIO m) => a -> PrintOperationCustomWidgetApplyCallback -> m SignalHandlerId+afterPrintOperationCustomWidgetApply obj cb = connectPrintOperationCustomWidgetApply obj cb SignalConnectAfter++connectPrintOperationCustomWidgetApply :: (GObject a, MonadIO m) =>+                                          a -> PrintOperationCustomWidgetApplyCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationCustomWidgetApply obj cb after = liftIO $ do+    cb' <- mkPrintOperationCustomWidgetApplyCallback (printOperationCustomWidgetApplyCallbackWrapper cb)+    connectSignalFunPtr obj "custom-widget-apply" cb' after++-- signal PrintOperation::done+type PrintOperationDoneCallback =+    PrintOperationResult ->+    IO ()++noPrintOperationDoneCallback :: Maybe PrintOperationDoneCallback+noPrintOperationDoneCallback = Nothing++type PrintOperationDoneCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationDoneCallback :: PrintOperationDoneCallbackC -> IO (FunPtr PrintOperationDoneCallbackC)++printOperationDoneClosure :: PrintOperationDoneCallback -> IO Closure+printOperationDoneClosure cb = newCClosure =<< mkPrintOperationDoneCallback wrapped+    where wrapped = printOperationDoneCallbackWrapper cb++printOperationDoneCallbackWrapper ::+    PrintOperationDoneCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+printOperationDoneCallbackWrapper _cb _ result_ _ = do+    let result_' = (toEnum . fromIntegral) result_+    _cb  result_'++onPrintOperationDone :: (GObject a, MonadIO m) => a -> PrintOperationDoneCallback -> m SignalHandlerId+onPrintOperationDone obj cb = liftIO $ connectPrintOperationDone obj cb SignalConnectBefore+afterPrintOperationDone :: (GObject a, MonadIO m) => a -> PrintOperationDoneCallback -> m SignalHandlerId+afterPrintOperationDone obj cb = connectPrintOperationDone obj cb SignalConnectAfter++connectPrintOperationDone :: (GObject a, MonadIO m) =>+                             a -> PrintOperationDoneCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationDone obj cb after = liftIO $ do+    cb' <- mkPrintOperationDoneCallback (printOperationDoneCallbackWrapper cb)+    connectSignalFunPtr obj "done" cb' after++-- signal PrintOperation::draw-page+type PrintOperationDrawPageCallback =+    PrintContext ->+    Int32 ->+    IO ()++noPrintOperationDrawPageCallback :: Maybe PrintOperationDrawPageCallback+noPrintOperationDrawPageCallback = Nothing++type PrintOperationDrawPageCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationDrawPageCallback :: PrintOperationDrawPageCallbackC -> IO (FunPtr PrintOperationDrawPageCallbackC)++printOperationDrawPageClosure :: PrintOperationDrawPageCallback -> IO Closure+printOperationDrawPageClosure cb = newCClosure =<< mkPrintOperationDrawPageCallback wrapped+    where wrapped = printOperationDrawPageCallbackWrapper cb++printOperationDrawPageCallbackWrapper ::+    PrintOperationDrawPageCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Int32 ->+    Ptr () ->+    IO ()+printOperationDrawPageCallbackWrapper _cb _ context page_nr _ = do+    context' <- (newObject PrintContext) context+    _cb  context' page_nr++onPrintOperationDrawPage :: (GObject a, MonadIO m) => a -> PrintOperationDrawPageCallback -> m SignalHandlerId+onPrintOperationDrawPage obj cb = liftIO $ connectPrintOperationDrawPage obj cb SignalConnectBefore+afterPrintOperationDrawPage :: (GObject a, MonadIO m) => a -> PrintOperationDrawPageCallback -> m SignalHandlerId+afterPrintOperationDrawPage obj cb = connectPrintOperationDrawPage obj cb SignalConnectAfter++connectPrintOperationDrawPage :: (GObject a, MonadIO m) =>+                                 a -> PrintOperationDrawPageCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationDrawPage obj cb after = liftIO $ do+    cb' <- mkPrintOperationDrawPageCallback (printOperationDrawPageCallbackWrapper cb)+    connectSignalFunPtr obj "draw-page" cb' after++-- signal PrintOperation::end-print+type PrintOperationEndPrintCallback =+    PrintContext ->+    IO ()++noPrintOperationEndPrintCallback :: Maybe PrintOperationEndPrintCallback+noPrintOperationEndPrintCallback = Nothing++type PrintOperationEndPrintCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationEndPrintCallback :: PrintOperationEndPrintCallbackC -> IO (FunPtr PrintOperationEndPrintCallbackC)++printOperationEndPrintClosure :: PrintOperationEndPrintCallback -> IO Closure+printOperationEndPrintClosure cb = newCClosure =<< mkPrintOperationEndPrintCallback wrapped+    where wrapped = printOperationEndPrintCallbackWrapper cb++printOperationEndPrintCallbackWrapper ::+    PrintOperationEndPrintCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Ptr () ->+    IO ()+printOperationEndPrintCallbackWrapper _cb _ context _ = do+    context' <- (newObject PrintContext) context+    _cb  context'++onPrintOperationEndPrint :: (GObject a, MonadIO m) => a -> PrintOperationEndPrintCallback -> m SignalHandlerId+onPrintOperationEndPrint obj cb = liftIO $ connectPrintOperationEndPrint obj cb SignalConnectBefore+afterPrintOperationEndPrint :: (GObject a, MonadIO m) => a -> PrintOperationEndPrintCallback -> m SignalHandlerId+afterPrintOperationEndPrint obj cb = connectPrintOperationEndPrint obj cb SignalConnectAfter++connectPrintOperationEndPrint :: (GObject a, MonadIO m) =>+                                 a -> PrintOperationEndPrintCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationEndPrint obj cb after = liftIO $ do+    cb' <- mkPrintOperationEndPrintCallback (printOperationEndPrintCallbackWrapper cb)+    connectSignalFunPtr obj "end-print" cb' after++-- signal PrintOperation::paginate+type PrintOperationPaginateCallback =+    PrintContext ->+    IO Bool++noPrintOperationPaginateCallback :: Maybe PrintOperationPaginateCallback+noPrintOperationPaginateCallback = Nothing++type PrintOperationPaginateCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPrintOperationPaginateCallback :: PrintOperationPaginateCallbackC -> IO (FunPtr PrintOperationPaginateCallbackC)++printOperationPaginateClosure :: PrintOperationPaginateCallback -> IO Closure+printOperationPaginateClosure cb = newCClosure =<< mkPrintOperationPaginateCallback wrapped+    where wrapped = printOperationPaginateCallbackWrapper cb++printOperationPaginateCallbackWrapper ::+    PrintOperationPaginateCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Ptr () ->+    IO CInt+printOperationPaginateCallbackWrapper _cb _ context _ = do+    context' <- (newObject PrintContext) context+    result <- _cb  context'+    let result' = (fromIntegral . fromEnum) result+    return result'++onPrintOperationPaginate :: (GObject a, MonadIO m) => a -> PrintOperationPaginateCallback -> m SignalHandlerId+onPrintOperationPaginate obj cb = liftIO $ connectPrintOperationPaginate obj cb SignalConnectBefore+afterPrintOperationPaginate :: (GObject a, MonadIO m) => a -> PrintOperationPaginateCallback -> m SignalHandlerId+afterPrintOperationPaginate obj cb = connectPrintOperationPaginate obj cb SignalConnectAfter++connectPrintOperationPaginate :: (GObject a, MonadIO m) =>+                                 a -> PrintOperationPaginateCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationPaginate obj cb after = liftIO $ do+    cb' <- mkPrintOperationPaginateCallback (printOperationPaginateCallbackWrapper cb)+    connectSignalFunPtr obj "paginate" cb' after++-- signal PrintOperation::preview+type PrintOperationPreviewCallback =+    PrintOperationPreview ->+    PrintContext ->+    Maybe Window ->+    IO Bool++noPrintOperationPreviewCallback :: Maybe PrintOperationPreviewCallback+noPrintOperationPreviewCallback = Nothing++type PrintOperationPreviewCallbackC =+    Ptr () ->                               -- object+    Ptr PrintOperationPreview ->+    Ptr PrintContext ->+    Ptr Window ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkPrintOperationPreviewCallback :: PrintOperationPreviewCallbackC -> IO (FunPtr PrintOperationPreviewCallbackC)++printOperationPreviewClosure :: PrintOperationPreviewCallback -> IO Closure+printOperationPreviewClosure cb = newCClosure =<< mkPrintOperationPreviewCallback wrapped+    where wrapped = printOperationPreviewCallbackWrapper cb++printOperationPreviewCallbackWrapper ::+    PrintOperationPreviewCallback ->+    Ptr () ->+    Ptr PrintOperationPreview ->+    Ptr PrintContext ->+    Ptr Window ->+    Ptr () ->+    IO CInt+printOperationPreviewCallbackWrapper _cb _ preview context parent _ = do+    preview' <- (newObject PrintOperationPreview) preview+    context' <- (newObject PrintContext) context+    maybeParent <-+        if parent == nullPtr+        then return Nothing+        else do+            parent' <- (newObject Window) parent+            return $ Just parent'+    result <- _cb  preview' context' maybeParent+    let result' = (fromIntegral . fromEnum) result+    return result'++onPrintOperationPreview :: (GObject a, MonadIO m) => a -> PrintOperationPreviewCallback -> m SignalHandlerId+onPrintOperationPreview obj cb = liftIO $ connectPrintOperationPreview obj cb SignalConnectBefore+afterPrintOperationPreview :: (GObject a, MonadIO m) => a -> PrintOperationPreviewCallback -> m SignalHandlerId+afterPrintOperationPreview obj cb = connectPrintOperationPreview obj cb SignalConnectAfter++connectPrintOperationPreview :: (GObject a, MonadIO m) =>+                                a -> PrintOperationPreviewCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationPreview obj cb after = liftIO $ do+    cb' <- mkPrintOperationPreviewCallback (printOperationPreviewCallbackWrapper cb)+    connectSignalFunPtr obj "preview" cb' after++-- signal PrintOperation::request-page-setup+type PrintOperationRequestPageSetupCallback =+    PrintContext ->+    Int32 ->+    PageSetup ->+    IO ()++noPrintOperationRequestPageSetupCallback :: Maybe PrintOperationRequestPageSetupCallback+noPrintOperationRequestPageSetupCallback = Nothing++type PrintOperationRequestPageSetupCallbackC =+    Ptr () ->                               -- object+    Ptr PrintContext ->+    Int32 ->+    Ptr PageSetup ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationRequestPageSetupCallback :: PrintOperationRequestPageSetupCallbackC -> IO (FunPtr PrintOperationRequestPageSetupCallbackC)++printOperationRequestPageSetupClosure :: PrintOperationRequestPageSetupCallback -> IO Closure+printOperationRequestPageSetupClosure cb = newCClosure =<< mkPrintOperationRequestPageSetupCallback wrapped+    where wrapped = printOperationRequestPageSetupCallbackWrapper cb++printOperationRequestPageSetupCallbackWrapper ::+    PrintOperationRequestPageSetupCallback ->+    Ptr () ->+    Ptr PrintContext ->+    Int32 ->+    Ptr PageSetup ->+    Ptr () ->+    IO ()+printOperationRequestPageSetupCallbackWrapper _cb _ context page_nr setup _ = do+    context' <- (newObject PrintContext) context+    setup' <- (newObject PageSetup) setup+    _cb  context' page_nr setup'++onPrintOperationRequestPageSetup :: (GObject a, MonadIO m) => a -> PrintOperationRequestPageSetupCallback -> m SignalHandlerId+onPrintOperationRequestPageSetup obj cb = liftIO $ connectPrintOperationRequestPageSetup obj cb SignalConnectBefore+afterPrintOperationRequestPageSetup :: (GObject a, MonadIO m) => a -> PrintOperationRequestPageSetupCallback -> m SignalHandlerId+afterPrintOperationRequestPageSetup obj cb = connectPrintOperationRequestPageSetup obj cb SignalConnectAfter++connectPrintOperationRequestPageSetup :: (GObject a, MonadIO m) =>+                                         a -> PrintOperationRequestPageSetupCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationRequestPageSetup obj cb after = liftIO $ do+    cb' <- mkPrintOperationRequestPageSetupCallback (printOperationRequestPageSetupCallbackWrapper cb)+    connectSignalFunPtr obj "request-page-setup" cb' after++-- signal PrintOperation::status-changed+type PrintOperationStatusChangedCallback =+    IO ()++noPrintOperationStatusChangedCallback :: Maybe PrintOperationStatusChangedCallback+noPrintOperationStatusChangedCallback = Nothing++type PrintOperationStatusChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationStatusChangedCallback :: PrintOperationStatusChangedCallbackC -> IO (FunPtr PrintOperationStatusChangedCallbackC)++printOperationStatusChangedClosure :: PrintOperationStatusChangedCallback -> IO Closure+printOperationStatusChangedClosure cb = newCClosure =<< mkPrintOperationStatusChangedCallback wrapped+    where wrapped = printOperationStatusChangedCallbackWrapper cb++printOperationStatusChangedCallbackWrapper ::+    PrintOperationStatusChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+printOperationStatusChangedCallbackWrapper _cb _ _ = do+    _cb ++onPrintOperationStatusChanged :: (GObject a, MonadIO m) => a -> PrintOperationStatusChangedCallback -> m SignalHandlerId+onPrintOperationStatusChanged obj cb = liftIO $ connectPrintOperationStatusChanged obj cb SignalConnectBefore+afterPrintOperationStatusChanged :: (GObject a, MonadIO m) => a -> PrintOperationStatusChangedCallback -> m SignalHandlerId+afterPrintOperationStatusChanged obj cb = connectPrintOperationStatusChanged obj cb SignalConnectAfter++connectPrintOperationStatusChanged :: (GObject a, MonadIO m) =>+                                      a -> PrintOperationStatusChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationStatusChanged obj cb after = liftIO $ do+    cb' <- mkPrintOperationStatusChangedCallback (printOperationStatusChangedCallbackWrapper cb)+    connectSignalFunPtr obj "status-changed" cb' after++-- signal PrintOperation::update-custom-widget+type PrintOperationUpdateCustomWidgetCallback =+    Widget ->+    PageSetup ->+    PrintSettings ->+    IO ()++noPrintOperationUpdateCustomWidgetCallback :: Maybe PrintOperationUpdateCustomWidgetCallback+noPrintOperationUpdateCustomWidgetCallback = Nothing++type PrintOperationUpdateCustomWidgetCallbackC =+    Ptr () ->                               -- object+    Ptr Widget ->+    Ptr PageSetup ->+    Ptr PrintSettings ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPrintOperationUpdateCustomWidgetCallback :: PrintOperationUpdateCustomWidgetCallbackC -> IO (FunPtr PrintOperationUpdateCustomWidgetCallbackC)++printOperationUpdateCustomWidgetClosure :: PrintOperationUpdateCustomWidgetCallback -> IO Closure+printOperationUpdateCustomWidgetClosure cb = newCClosure =<< mkPrintOperationUpdateCustomWidgetCallback wrapped+    where wrapped = printOperationUpdateCustomWidgetCallbackWrapper cb++printOperationUpdateCustomWidgetCallbackWrapper ::+    PrintOperationUpdateCustomWidgetCallback ->+    Ptr () ->+    Ptr Widget ->+    Ptr PageSetup ->+    Ptr PrintSettings ->+    Ptr () ->+    IO ()+printOperationUpdateCustomWidgetCallbackWrapper _cb _ widget setup settings _ = do+    widget' <- (newObject Widget) widget+    setup' <- (newObject PageSetup) setup+    settings' <- (newObject PrintSettings) settings+    _cb  widget' setup' settings'++onPrintOperationUpdateCustomWidget :: (GObject a, MonadIO m) => a -> PrintOperationUpdateCustomWidgetCallback -> m SignalHandlerId+onPrintOperationUpdateCustomWidget obj cb = liftIO $ connectPrintOperationUpdateCustomWidget obj cb SignalConnectBefore+afterPrintOperationUpdateCustomWidget :: (GObject a, MonadIO m) => a -> PrintOperationUpdateCustomWidgetCallback -> m SignalHandlerId+afterPrintOperationUpdateCustomWidget obj cb = connectPrintOperationUpdateCustomWidget obj cb SignalConnectAfter++connectPrintOperationUpdateCustomWidget :: (GObject a, MonadIO m) =>+                                           a -> PrintOperationUpdateCustomWidgetCallback -> SignalConnectMode -> m SignalHandlerId+connectPrintOperationUpdateCustomWidget obj cb after = liftIO $ do+    cb' <- mkPrintOperationUpdateCustomWidgetCallback (printOperationUpdateCustomWidgetCallbackWrapper cb)+    connectSignalFunPtr obj "update-custom-widget" cb' after++-- VVV Prop "allow-async"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationAllowAsync :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationAllowAsync obj = liftIO $ getObjectPropertyBool obj "allow-async"++setPrintOperationAllowAsync :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationAllowAsync obj val = liftIO $ setObjectPropertyBool obj "allow-async" val++constructPrintOperationAllowAsync :: Bool -> IO ([Char], GValue)+constructPrintOperationAllowAsync val = constructObjectPropertyBool "allow-async" val++data PrintOperationAllowAsyncPropertyInfo+instance AttrInfo PrintOperationAllowAsyncPropertyInfo where+    type AttrAllowedOps PrintOperationAllowAsyncPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationAllowAsyncPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationAllowAsyncPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationAllowAsyncPropertyInfo = Bool+    type AttrLabel PrintOperationAllowAsyncPropertyInfo = "PrintOperation::allow-async"+    attrGet _ = getPrintOperationAllowAsync+    attrSet _ = setPrintOperationAllowAsync+    attrConstruct _ = constructPrintOperationAllowAsync++-- VVV Prop "current-page"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationCurrentPage :: (MonadIO m, PrintOperationK o) => o -> m Int32+getPrintOperationCurrentPage obj = liftIO $ getObjectPropertyCInt obj "current-page"++setPrintOperationCurrentPage :: (MonadIO m, PrintOperationK o) => o -> Int32 -> m ()+setPrintOperationCurrentPage obj val = liftIO $ setObjectPropertyCInt obj "current-page" val++constructPrintOperationCurrentPage :: Int32 -> IO ([Char], GValue)+constructPrintOperationCurrentPage val = constructObjectPropertyCInt "current-page" val++data PrintOperationCurrentPagePropertyInfo+instance AttrInfo PrintOperationCurrentPagePropertyInfo where+    type AttrAllowedOps PrintOperationCurrentPagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationCurrentPagePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PrintOperationCurrentPagePropertyInfo = PrintOperationK+    type AttrGetType PrintOperationCurrentPagePropertyInfo = Int32+    type AttrLabel PrintOperationCurrentPagePropertyInfo = "PrintOperation::current-page"+    attrGet _ = getPrintOperationCurrentPage+    attrSet _ = setPrintOperationCurrentPage+    attrConstruct _ = constructPrintOperationCurrentPage++-- VVV Prop "custom-tab-label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationCustomTabLabel :: (MonadIO m, PrintOperationK o) => o -> m T.Text+getPrintOperationCustomTabLabel obj = liftIO $ getObjectPropertyString obj "custom-tab-label"++setPrintOperationCustomTabLabel :: (MonadIO m, PrintOperationK o) => o -> T.Text -> m ()+setPrintOperationCustomTabLabel obj val = liftIO $ setObjectPropertyString obj "custom-tab-label" val++constructPrintOperationCustomTabLabel :: T.Text -> IO ([Char], GValue)+constructPrintOperationCustomTabLabel val = constructObjectPropertyString "custom-tab-label" val++data PrintOperationCustomTabLabelPropertyInfo+instance AttrInfo PrintOperationCustomTabLabelPropertyInfo where+    type AttrAllowedOps PrintOperationCustomTabLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationCustomTabLabelPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PrintOperationCustomTabLabelPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationCustomTabLabelPropertyInfo = T.Text+    type AttrLabel PrintOperationCustomTabLabelPropertyInfo = "PrintOperation::custom-tab-label"+    attrGet _ = getPrintOperationCustomTabLabel+    attrSet _ = setPrintOperationCustomTabLabel+    attrConstruct _ = constructPrintOperationCustomTabLabel++-- VVV Prop "default-page-setup"+   -- Type: TInterface "Gtk" "PageSetup"+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationDefaultPageSetup :: (MonadIO m, PrintOperationK o) => o -> m PageSetup+getPrintOperationDefaultPageSetup obj = liftIO $ getObjectPropertyObject obj "default-page-setup" PageSetup++setPrintOperationDefaultPageSetup :: (MonadIO m, PrintOperationK o, PageSetupK a) => o -> a -> m ()+setPrintOperationDefaultPageSetup obj val = liftIO $ setObjectPropertyObject obj "default-page-setup" val++constructPrintOperationDefaultPageSetup :: (PageSetupK a) => a -> IO ([Char], GValue)+constructPrintOperationDefaultPageSetup val = constructObjectPropertyObject "default-page-setup" val++data PrintOperationDefaultPageSetupPropertyInfo+instance AttrInfo PrintOperationDefaultPageSetupPropertyInfo where+    type AttrAllowedOps PrintOperationDefaultPageSetupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationDefaultPageSetupPropertyInfo = PageSetupK+    type AttrBaseTypeConstraint PrintOperationDefaultPageSetupPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationDefaultPageSetupPropertyInfo = PageSetup+    type AttrLabel PrintOperationDefaultPageSetupPropertyInfo = "PrintOperation::default-page-setup"+    attrGet _ = getPrintOperationDefaultPageSetup+    attrSet _ = setPrintOperationDefaultPageSetup+    attrConstruct _ = constructPrintOperationDefaultPageSetup++-- VVV Prop "embed-page-setup"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationEmbedPageSetup :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationEmbedPageSetup obj = liftIO $ getObjectPropertyBool obj "embed-page-setup"++setPrintOperationEmbedPageSetup :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationEmbedPageSetup obj val = liftIO $ setObjectPropertyBool obj "embed-page-setup" val++constructPrintOperationEmbedPageSetup :: Bool -> IO ([Char], GValue)+constructPrintOperationEmbedPageSetup val = constructObjectPropertyBool "embed-page-setup" val++data PrintOperationEmbedPageSetupPropertyInfo+instance AttrInfo PrintOperationEmbedPageSetupPropertyInfo where+    type AttrAllowedOps PrintOperationEmbedPageSetupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationEmbedPageSetupPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationEmbedPageSetupPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationEmbedPageSetupPropertyInfo = Bool+    type AttrLabel PrintOperationEmbedPageSetupPropertyInfo = "PrintOperation::embed-page-setup"+    attrGet _ = getPrintOperationEmbedPageSetup+    attrSet _ = setPrintOperationEmbedPageSetup+    attrConstruct _ = constructPrintOperationEmbedPageSetup++-- VVV Prop "export-filename"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationExportFilename :: (MonadIO m, PrintOperationK o) => o -> m T.Text+getPrintOperationExportFilename obj = liftIO $ getObjectPropertyString obj "export-filename"++setPrintOperationExportFilename :: (MonadIO m, PrintOperationK o) => o -> T.Text -> m ()+setPrintOperationExportFilename obj val = liftIO $ setObjectPropertyString obj "export-filename" val++constructPrintOperationExportFilename :: T.Text -> IO ([Char], GValue)+constructPrintOperationExportFilename val = constructObjectPropertyString "export-filename" val++data PrintOperationExportFilenamePropertyInfo+instance AttrInfo PrintOperationExportFilenamePropertyInfo where+    type AttrAllowedOps PrintOperationExportFilenamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationExportFilenamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PrintOperationExportFilenamePropertyInfo = PrintOperationK+    type AttrGetType PrintOperationExportFilenamePropertyInfo = T.Text+    type AttrLabel PrintOperationExportFilenamePropertyInfo = "PrintOperation::export-filename"+    attrGet _ = getPrintOperationExportFilename+    attrSet _ = setPrintOperationExportFilename+    attrConstruct _ = constructPrintOperationExportFilename++-- VVV Prop "has-selection"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationHasSelection :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationHasSelection obj = liftIO $ getObjectPropertyBool obj "has-selection"++setPrintOperationHasSelection :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationHasSelection obj val = liftIO $ setObjectPropertyBool obj "has-selection" val++constructPrintOperationHasSelection :: Bool -> IO ([Char], GValue)+constructPrintOperationHasSelection val = constructObjectPropertyBool "has-selection" val++data PrintOperationHasSelectionPropertyInfo+instance AttrInfo PrintOperationHasSelectionPropertyInfo where+    type AttrAllowedOps PrintOperationHasSelectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationHasSelectionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationHasSelectionPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationHasSelectionPropertyInfo = Bool+    type AttrLabel PrintOperationHasSelectionPropertyInfo = "PrintOperation::has-selection"+    attrGet _ = getPrintOperationHasSelection+    attrSet _ = setPrintOperationHasSelection+    attrConstruct _ = constructPrintOperationHasSelection++-- VVV Prop "job-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationJobName :: (MonadIO m, PrintOperationK o) => o -> m T.Text+getPrintOperationJobName obj = liftIO $ getObjectPropertyString obj "job-name"++setPrintOperationJobName :: (MonadIO m, PrintOperationK o) => o -> T.Text -> m ()+setPrintOperationJobName obj val = liftIO $ setObjectPropertyString obj "job-name" val++constructPrintOperationJobName :: T.Text -> IO ([Char], GValue)+constructPrintOperationJobName val = constructObjectPropertyString "job-name" val++data PrintOperationJobNamePropertyInfo+instance AttrInfo PrintOperationJobNamePropertyInfo where+    type AttrAllowedOps PrintOperationJobNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationJobNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PrintOperationJobNamePropertyInfo = PrintOperationK+    type AttrGetType PrintOperationJobNamePropertyInfo = T.Text+    type AttrLabel PrintOperationJobNamePropertyInfo = "PrintOperation::job-name"+    attrGet _ = getPrintOperationJobName+    attrSet _ = setPrintOperationJobName+    attrConstruct _ = constructPrintOperationJobName++-- VVV Prop "n-pages"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationNPages :: (MonadIO m, PrintOperationK o) => o -> m Int32+getPrintOperationNPages obj = liftIO $ getObjectPropertyCInt obj "n-pages"++setPrintOperationNPages :: (MonadIO m, PrintOperationK o) => o -> Int32 -> m ()+setPrintOperationNPages obj val = liftIO $ setObjectPropertyCInt obj "n-pages" val++constructPrintOperationNPages :: Int32 -> IO ([Char], GValue)+constructPrintOperationNPages val = constructObjectPropertyCInt "n-pages" val++data PrintOperationNPagesPropertyInfo+instance AttrInfo PrintOperationNPagesPropertyInfo where+    type AttrAllowedOps PrintOperationNPagesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationNPagesPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PrintOperationNPagesPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationNPagesPropertyInfo = Int32+    type AttrLabel PrintOperationNPagesPropertyInfo = "PrintOperation::n-pages"+    attrGet _ = getPrintOperationNPages+    attrSet _ = setPrintOperationNPages+    attrConstruct _ = constructPrintOperationNPages++-- VVV Prop "n-pages-to-print"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getPrintOperationNPagesToPrint :: (MonadIO m, PrintOperationK o) => o -> m Int32+getPrintOperationNPagesToPrint obj = liftIO $ getObjectPropertyCInt obj "n-pages-to-print"++data PrintOperationNPagesToPrintPropertyInfo+instance AttrInfo PrintOperationNPagesToPrintPropertyInfo where+    type AttrAllowedOps PrintOperationNPagesToPrintPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PrintOperationNPagesToPrintPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PrintOperationNPagesToPrintPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationNPagesToPrintPropertyInfo = Int32+    type AttrLabel PrintOperationNPagesToPrintPropertyInfo = "PrintOperation::n-pages-to-print"+    attrGet _ = getPrintOperationNPagesToPrint+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "print-settings"+   -- Type: TInterface "Gtk" "PrintSettings"+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationPrintSettings :: (MonadIO m, PrintOperationK o) => o -> m PrintSettings+getPrintOperationPrintSettings obj = liftIO $ getObjectPropertyObject obj "print-settings" PrintSettings++setPrintOperationPrintSettings :: (MonadIO m, PrintOperationK o, PrintSettingsK a) => o -> a -> m ()+setPrintOperationPrintSettings obj val = liftIO $ setObjectPropertyObject obj "print-settings" val++constructPrintOperationPrintSettings :: (PrintSettingsK a) => a -> IO ([Char], GValue)+constructPrintOperationPrintSettings val = constructObjectPropertyObject "print-settings" val++data PrintOperationPrintSettingsPropertyInfo+instance AttrInfo PrintOperationPrintSettingsPropertyInfo where+    type AttrAllowedOps PrintOperationPrintSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationPrintSettingsPropertyInfo = PrintSettingsK+    type AttrBaseTypeConstraint PrintOperationPrintSettingsPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationPrintSettingsPropertyInfo = PrintSettings+    type AttrLabel PrintOperationPrintSettingsPropertyInfo = "PrintOperation::print-settings"+    attrGet _ = getPrintOperationPrintSettings+    attrSet _ = setPrintOperationPrintSettings+    attrConstruct _ = constructPrintOperationPrintSettings++-- VVV Prop "show-progress"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationShowProgress :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationShowProgress obj = liftIO $ getObjectPropertyBool obj "show-progress"++setPrintOperationShowProgress :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationShowProgress obj val = liftIO $ setObjectPropertyBool obj "show-progress" val++constructPrintOperationShowProgress :: Bool -> IO ([Char], GValue)+constructPrintOperationShowProgress val = constructObjectPropertyBool "show-progress" val++data PrintOperationShowProgressPropertyInfo+instance AttrInfo PrintOperationShowProgressPropertyInfo where+    type AttrAllowedOps PrintOperationShowProgressPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationShowProgressPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationShowProgressPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationShowProgressPropertyInfo = Bool+    type AttrLabel PrintOperationShowProgressPropertyInfo = "PrintOperation::show-progress"+    attrGet _ = getPrintOperationShowProgress+    attrSet _ = setPrintOperationShowProgress+    attrConstruct _ = constructPrintOperationShowProgress++-- VVV Prop "status"+   -- Type: TInterface "Gtk" "PrintStatus"+   -- Flags: [PropertyReadable]++getPrintOperationStatus :: (MonadIO m, PrintOperationK o) => o -> m PrintStatus+getPrintOperationStatus obj = liftIO $ getObjectPropertyEnum obj "status"++data PrintOperationStatusPropertyInfo+instance AttrInfo PrintOperationStatusPropertyInfo where+    type AttrAllowedOps PrintOperationStatusPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PrintOperationStatusPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PrintOperationStatusPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationStatusPropertyInfo = PrintStatus+    type AttrLabel PrintOperationStatusPropertyInfo = "PrintOperation::status"+    attrGet _ = getPrintOperationStatus+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "status-string"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getPrintOperationStatusString :: (MonadIO m, PrintOperationK o) => o -> m T.Text+getPrintOperationStatusString obj = liftIO $ getObjectPropertyString obj "status-string"++data PrintOperationStatusStringPropertyInfo+instance AttrInfo PrintOperationStatusStringPropertyInfo where+    type AttrAllowedOps PrintOperationStatusStringPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PrintOperationStatusStringPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PrintOperationStatusStringPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationStatusStringPropertyInfo = T.Text+    type AttrLabel PrintOperationStatusStringPropertyInfo = "PrintOperation::status-string"+    attrGet _ = getPrintOperationStatusString+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "support-selection"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationSupportSelection :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationSupportSelection obj = liftIO $ getObjectPropertyBool obj "support-selection"++setPrintOperationSupportSelection :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationSupportSelection obj val = liftIO $ setObjectPropertyBool obj "support-selection" val++constructPrintOperationSupportSelection :: Bool -> IO ([Char], GValue)+constructPrintOperationSupportSelection val = constructObjectPropertyBool "support-selection" val++data PrintOperationSupportSelectionPropertyInfo+instance AttrInfo PrintOperationSupportSelectionPropertyInfo where+    type AttrAllowedOps PrintOperationSupportSelectionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationSupportSelectionPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationSupportSelectionPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationSupportSelectionPropertyInfo = Bool+    type AttrLabel PrintOperationSupportSelectionPropertyInfo = "PrintOperation::support-selection"+    attrGet _ = getPrintOperationSupportSelection+    attrSet _ = setPrintOperationSupportSelection+    attrConstruct _ = constructPrintOperationSupportSelection++-- VVV Prop "track-print-status"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationTrackPrintStatus :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationTrackPrintStatus obj = liftIO $ getObjectPropertyBool obj "track-print-status"++setPrintOperationTrackPrintStatus :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationTrackPrintStatus obj val = liftIO $ setObjectPropertyBool obj "track-print-status" val++constructPrintOperationTrackPrintStatus :: Bool -> IO ([Char], GValue)+constructPrintOperationTrackPrintStatus val = constructObjectPropertyBool "track-print-status" val++data PrintOperationTrackPrintStatusPropertyInfo+instance AttrInfo PrintOperationTrackPrintStatusPropertyInfo where+    type AttrAllowedOps PrintOperationTrackPrintStatusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationTrackPrintStatusPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationTrackPrintStatusPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationTrackPrintStatusPropertyInfo = Bool+    type AttrLabel PrintOperationTrackPrintStatusPropertyInfo = "PrintOperation::track-print-status"+    attrGet _ = getPrintOperationTrackPrintStatus+    attrSet _ = setPrintOperationTrackPrintStatus+    attrConstruct _ = constructPrintOperationTrackPrintStatus++-- VVV Prop "unit"+   -- Type: TInterface "Gtk" "Unit"+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationUnit :: (MonadIO m, PrintOperationK o) => o -> m Unit+getPrintOperationUnit obj = liftIO $ getObjectPropertyEnum obj "unit"++setPrintOperationUnit :: (MonadIO m, PrintOperationK o) => o -> Unit -> m ()+setPrintOperationUnit obj val = liftIO $ setObjectPropertyEnum obj "unit" val++constructPrintOperationUnit :: Unit -> IO ([Char], GValue)+constructPrintOperationUnit val = constructObjectPropertyEnum "unit" val++data PrintOperationUnitPropertyInfo+instance AttrInfo PrintOperationUnitPropertyInfo where+    type AttrAllowedOps PrintOperationUnitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationUnitPropertyInfo = (~) Unit+    type AttrBaseTypeConstraint PrintOperationUnitPropertyInfo = PrintOperationK+    type AttrGetType PrintOperationUnitPropertyInfo = Unit+    type AttrLabel PrintOperationUnitPropertyInfo = "PrintOperation::unit"+    attrGet _ = getPrintOperationUnit+    attrSet _ = setPrintOperationUnit+    attrConstruct _ = constructPrintOperationUnit++-- VVV Prop "use-full-page"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPrintOperationUseFullPage :: (MonadIO m, PrintOperationK o) => o -> m Bool+getPrintOperationUseFullPage obj = liftIO $ getObjectPropertyBool obj "use-full-page"++setPrintOperationUseFullPage :: (MonadIO m, PrintOperationK o) => o -> Bool -> m ()+setPrintOperationUseFullPage obj val = liftIO $ setObjectPropertyBool obj "use-full-page" val++constructPrintOperationUseFullPage :: Bool -> IO ([Char], GValue)+constructPrintOperationUseFullPage val = constructObjectPropertyBool "use-full-page" val++data PrintOperationUseFullPagePropertyInfo+instance AttrInfo PrintOperationUseFullPagePropertyInfo where+    type AttrAllowedOps PrintOperationUseFullPagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PrintOperationUseFullPagePropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PrintOperationUseFullPagePropertyInfo = PrintOperationK+    type AttrGetType PrintOperationUseFullPagePropertyInfo = Bool+    type AttrLabel PrintOperationUseFullPagePropertyInfo = "PrintOperation::use-full-page"+    attrGet _ = getPrintOperationUseFullPage+    attrSet _ = setPrintOperationUseFullPage+    attrConstruct _ = constructPrintOperationUseFullPage++type instance AttributeList PrintOperation = PrintOperationAttributeList+type PrintOperationAttributeList = ('[ '("allow-async", PrintOperationAllowAsyncPropertyInfo), '("current-page", PrintOperationCurrentPagePropertyInfo), '("custom-tab-label", PrintOperationCustomTabLabelPropertyInfo), '("default-page-setup", PrintOperationDefaultPageSetupPropertyInfo), '("embed-page-setup", PrintOperationEmbedPageSetupPropertyInfo), '("export-filename", PrintOperationExportFilenamePropertyInfo), '("has-selection", PrintOperationHasSelectionPropertyInfo), '("job-name", PrintOperationJobNamePropertyInfo), '("n-pages", PrintOperationNPagesPropertyInfo), '("n-pages-to-print", PrintOperationNPagesToPrintPropertyInfo), '("print-settings", PrintOperationPrintSettingsPropertyInfo), '("show-progress", PrintOperationShowProgressPropertyInfo), '("status", PrintOperationStatusPropertyInfo), '("status-string", PrintOperationStatusStringPropertyInfo), '("support-selection", PrintOperationSupportSelectionPropertyInfo), '("track-print-status", PrintOperationTrackPrintStatusPropertyInfo), '("unit", PrintOperationUnitPropertyInfo), '("use-full-page", PrintOperationUseFullPagePropertyInfo)] :: [(Symbol, *)])++data PrintOperationBeginPrintSignalInfo+instance SignalInfo PrintOperationBeginPrintSignalInfo where+    type HaskellCallbackType PrintOperationBeginPrintSignalInfo = PrintOperationBeginPrintCallback+    connectSignal _ = connectPrintOperationBeginPrint++data PrintOperationCreateCustomWidgetSignalInfo+instance SignalInfo PrintOperationCreateCustomWidgetSignalInfo where+    type HaskellCallbackType PrintOperationCreateCustomWidgetSignalInfo = PrintOperationCreateCustomWidgetCallback+    connectSignal _ = connectPrintOperationCreateCustomWidget++data PrintOperationCustomWidgetApplySignalInfo+instance SignalInfo PrintOperationCustomWidgetApplySignalInfo where+    type HaskellCallbackType PrintOperationCustomWidgetApplySignalInfo = PrintOperationCustomWidgetApplyCallback+    connectSignal _ = connectPrintOperationCustomWidgetApply++data PrintOperationDoneSignalInfo+instance SignalInfo PrintOperationDoneSignalInfo where+    type HaskellCallbackType PrintOperationDoneSignalInfo = PrintOperationDoneCallback+    connectSignal _ = connectPrintOperationDone++data PrintOperationDrawPageSignalInfo+instance SignalInfo PrintOperationDrawPageSignalInfo where+    type HaskellCallbackType PrintOperationDrawPageSignalInfo = PrintOperationDrawPageCallback+    connectSignal _ = connectPrintOperationDrawPage++data PrintOperationEndPrintSignalInfo+instance SignalInfo PrintOperationEndPrintSignalInfo where+    type HaskellCallbackType PrintOperationEndPrintSignalInfo = PrintOperationEndPrintCallback+    connectSignal _ = connectPrintOperationEndPrint++data PrintOperationPaginateSignalInfo+instance SignalInfo PrintOperationPaginateSignalInfo where+    type HaskellCallbackType PrintOperationPaginateSignalInfo = PrintOperationPaginateCallback+    connectSignal _ = connectPrintOperationPaginate++data PrintOperationPreviewSignalInfo+instance SignalInfo PrintOperationPreviewSignalInfo where+    type HaskellCallbackType PrintOperationPreviewSignalInfo = PrintOperationPreviewCallback+    connectSignal _ = connectPrintOperationPreview++data PrintOperationRequestPageSetupSignalInfo+instance SignalInfo PrintOperationRequestPageSetupSignalInfo where+    type HaskellCallbackType PrintOperationRequestPageSetupSignalInfo = PrintOperationRequestPageSetupCallback+    connectSignal _ = connectPrintOperationRequestPageSetup++data PrintOperationStatusChangedSignalInfo+instance SignalInfo PrintOperationStatusChangedSignalInfo where+    type HaskellCallbackType PrintOperationStatusChangedSignalInfo = PrintOperationStatusChangedCallback+    connectSignal _ = connectPrintOperationStatusChanged++data PrintOperationUpdateCustomWidgetSignalInfo+instance SignalInfo PrintOperationUpdateCustomWidgetSignalInfo where+    type HaskellCallbackType PrintOperationUpdateCustomWidgetSignalInfo = PrintOperationUpdateCustomWidgetCallback+    connectSignal _ = connectPrintOperationUpdateCustomWidget++type instance SignalList PrintOperation = PrintOperationSignalList+type PrintOperationSignalList = ('[ '("begin-print", PrintOperationBeginPrintSignalInfo), '("create-custom-widget", PrintOperationCreateCustomWidgetSignalInfo), '("custom-widget-apply", PrintOperationCustomWidgetApplySignalInfo), '("done", PrintOperationDoneSignalInfo), '("draw-page", PrintOperationDrawPageSignalInfo), '("end-print", PrintOperationEndPrintSignalInfo), '("got-page-size", PrintOperationPreviewGotPageSizeSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("paginate", PrintOperationPaginateSignalInfo), '("preview", PrintOperationPreviewSignalInfo), '("ready", PrintOperationPreviewReadySignalInfo), '("request-page-setup", PrintOperationRequestPageSetupSignalInfo), '("status-changed", PrintOperationStatusChangedSignalInfo), '("update-custom-widget", PrintOperationUpdateCustomWidgetSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PrintOperation::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "PrintOperation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_new" gtk_print_operation_new :: +    IO (Ptr PrintOperation)+++printOperationNew ::+    (MonadIO m) =>+    m PrintOperation+printOperationNew  = liftIO $ do+    result <- gtk_print_operation_new+    checkUnexpectedReturnNULL "gtk_print_operation_new" result+    result' <- (wrapObject PrintOperation) result+    return result'++-- method PrintOperation::cancel+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_cancel" gtk_print_operation_cancel :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO ()+++printOperationCancel ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m ()+printOperationCancel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_cancel _obj'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::draw_page_finish+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_draw_page_finish" gtk_print_operation_draw_page_finish :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO ()+++printOperationDrawPageFinish ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m ()+printOperationDrawPageFinish _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_draw_page_finish _obj'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::get_default_page_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSetup"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_default_page_setup" gtk_print_operation_get_default_page_setup :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO (Ptr PageSetup)+++printOperationGetDefaultPageSetup ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m PageSetup+printOperationGetDefaultPageSetup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_default_page_setup _obj'+    checkUnexpectedReturnNULL "gtk_print_operation_get_default_page_setup" result+    result' <- (newObject PageSetup) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_embed_page_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_embed_page_setup" gtk_print_operation_get_embed_page_setup :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CInt+++printOperationGetEmbedPageSetup ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m Bool+printOperationGetEmbedPageSetup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_embed_page_setup _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_error+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_operation_get_error" gtk_print_operation_get_error :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    Ptr (Ptr GError) ->                     -- error+    IO ()+++printOperationGetError ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m ()+printOperationGetError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        propagateGError $ gtk_print_operation_get_error _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++-- method PrintOperation::get_has_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_has_selection" gtk_print_operation_get_has_selection :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CInt+++printOperationGetHasSelection ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m Bool+printOperationGetHasSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_has_selection _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_n_pages_to_print+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_n_pages_to_print" gtk_print_operation_get_n_pages_to_print :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO Int32+++printOperationGetNPagesToPrint ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m Int32+printOperationGetNPagesToPrint _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_n_pages_to_print _obj'+    touchManagedPtr _obj+    return result++-- method PrintOperation::get_print_settings+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintSettings"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_print_settings" gtk_print_operation_get_print_settings :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO (Ptr PrintSettings)+++printOperationGetPrintSettings ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m PrintSettings+printOperationGetPrintSettings _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_print_settings _obj'+    checkUnexpectedReturnNULL "gtk_print_operation_get_print_settings" result+    result' <- (newObject PrintSettings) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintStatus"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_status" gtk_print_operation_get_status :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CUInt+++printOperationGetStatus ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m PrintStatus+printOperationGetStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_status _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_status_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_status_string" gtk_print_operation_get_status_string :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CString+++printOperationGetStatusString ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m T.Text+printOperationGetStatusString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_status_string _obj'+    checkUnexpectedReturnNULL "gtk_print_operation_get_status_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::get_support_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_get_support_selection" gtk_print_operation_get_support_selection :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CInt+++printOperationGetSupportSelection ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m Bool+printOperationGetSupportSelection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_get_support_selection _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::is_finished+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_is_finished" gtk_print_operation_is_finished :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO CInt+++printOperationIsFinished ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m Bool+printOperationIsFinished _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_operation_is_finished _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintOperation::run+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "PrintOperationAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "action", argType = TInterface "Gtk" "PrintOperationAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "parent", argType = TInterface "Gtk" "Window", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintOperationResult"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_operation_run" gtk_print_operation_run :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CUInt ->                                -- action : TInterface "Gtk" "PrintOperationAction"+    Ptr Window ->                           -- parent : TInterface "Gtk" "Window"+    Ptr (Ptr GError) ->                     -- error+    IO CUInt+++printOperationRun ::+    (MonadIO m, PrintOperationK a, WindowK b) =>+    a ->                                    -- _obj+    PrintOperationAction ->                 -- action+    Maybe (b) ->                            -- parent+    m PrintOperationResult+printOperationRun _obj action parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let action' = (fromIntegral . fromEnum) action+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    onException (do+        result <- propagateGError $ gtk_print_operation_run _obj' action' maybeParent+        let result' = (toEnum . fromIntegral) result+        touchManagedPtr _obj+        whenJust parent touchManagedPtr+        return result'+     ) (do+        return ()+     )++-- method PrintOperation::set_allow_async+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_async", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "allow_async", 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 "gtk_print_operation_set_allow_async" gtk_print_operation_set_allow_async :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- allow_async : TBasicType TBoolean+    IO ()+++printOperationSetAllowAsync ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- allow_async+    m ()+printOperationSetAllowAsync _obj allow_async = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let allow_async' = (fromIntegral . fromEnum) allow_async+    gtk_print_operation_set_allow_async _obj' allow_async'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_current_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "current_page", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "current_page", 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 "gtk_print_operation_set_current_page" gtk_print_operation_set_current_page :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    Int32 ->                                -- current_page : TBasicType TInt32+    IO ()+++printOperationSetCurrentPage ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- current_page+    m ()+printOperationSetCurrentPage _obj current_page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_set_current_page _obj' current_page+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_custom_tab_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", 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 "Gtk" "PrintOperation", 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 "gtk_print_operation_set_custom_tab_label" gtk_print_operation_set_custom_tab_label :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++printOperationSetCustomTabLabel ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+printOperationSetCustomTabLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    gtk_print_operation_set_custom_tab_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method PrintOperation::set_default_page_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_page_setup", argType = TInterface "Gtk" "PageSetup", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_set_default_page_setup" gtk_print_operation_set_default_page_setup :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    Ptr PageSetup ->                        -- default_page_setup : TInterface "Gtk" "PageSetup"+    IO ()+++printOperationSetDefaultPageSetup ::+    (MonadIO m, PrintOperationK a, PageSetupK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- default_page_setup+    m ()+printOperationSetDefaultPageSetup _obj default_page_setup = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeDefault_page_setup <- case default_page_setup of+        Nothing -> return nullPtr+        Just jDefault_page_setup -> do+            let jDefault_page_setup' = unsafeManagedPtrCastPtr jDefault_page_setup+            return jDefault_page_setup'+    gtk_print_operation_set_default_page_setup _obj' maybeDefault_page_setup+    touchManagedPtr _obj+    whenJust default_page_setup touchManagedPtr+    return ()++-- method PrintOperation::set_defer_drawing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_set_defer_drawing" gtk_print_operation_set_defer_drawing :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    IO ()+++printOperationSetDeferDrawing ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    m ()+printOperationSetDeferDrawing _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_set_defer_drawing _obj'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_embed_page_setup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "embed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "embed", 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 "gtk_print_operation_set_embed_page_setup" gtk_print_operation_set_embed_page_setup :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- embed : TBasicType TBoolean+    IO ()+++printOperationSetEmbedPageSetup ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- embed+    m ()+printOperationSetEmbedPageSetup _obj embed = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let embed' = (fromIntegral . fromEnum) embed+    gtk_print_operation_set_embed_page_setup _obj' embed'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_export_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_set_export_filename" gtk_print_operation_set_export_filename :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CString ->                              -- filename : TBasicType TFileName+    IO ()+++printOperationSetExportFilename ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- filename+    m ()+printOperationSetExportFilename _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- stringToCString filename+    gtk_print_operation_set_export_filename _obj' filename'+    touchManagedPtr _obj+    freeMem filename'+    return ()++-- method PrintOperation::set_has_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_selection", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "has_selection", 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 "gtk_print_operation_set_has_selection" gtk_print_operation_set_has_selection :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- has_selection : TBasicType TBoolean+    IO ()+++printOperationSetHasSelection ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- has_selection+    m ()+printOperationSetHasSelection _obj has_selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let has_selection' = (fromIntegral . fromEnum) has_selection+    gtk_print_operation_set_has_selection _obj' has_selection'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_job_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "job_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "job_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 "gtk_print_operation_set_job_name" gtk_print_operation_set_job_name :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CString ->                              -- job_name : TBasicType TUTF8+    IO ()+++printOperationSetJobName ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- job_name+    m ()+printOperationSetJobName _obj job_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    job_name' <- textToCString job_name+    gtk_print_operation_set_job_name _obj' job_name'+    touchManagedPtr _obj+    freeMem job_name'+    return ()++-- method PrintOperation::set_n_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", 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 "gtk_print_operation_set_n_pages" gtk_print_operation_set_n_pages :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    Int32 ->                                -- n_pages : TBasicType TInt32+    IO ()+++printOperationSetNPages ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_pages+    m ()+printOperationSetNPages _obj n_pages = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_operation_set_n_pages _obj' n_pages+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_print_settings+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "print_settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "print_settings", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_set_print_settings" gtk_print_operation_set_print_settings :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    Ptr PrintSettings ->                    -- print_settings : TInterface "Gtk" "PrintSettings"+    IO ()+++printOperationSetPrintSettings ::+    (MonadIO m, PrintOperationK a, PrintSettingsK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- print_settings+    m ()+printOperationSetPrintSettings _obj print_settings = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePrint_settings <- case print_settings of+        Nothing -> return nullPtr+        Just jPrint_settings -> do+            let jPrint_settings' = unsafeManagedPtrCastPtr jPrint_settings+            return jPrint_settings'+    gtk_print_operation_set_print_settings _obj' maybePrint_settings+    touchManagedPtr _obj+    whenJust print_settings touchManagedPtr+    return ()++-- method PrintOperation::set_show_progress+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_progress", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_progress", 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 "gtk_print_operation_set_show_progress" gtk_print_operation_set_show_progress :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- show_progress : TBasicType TBoolean+    IO ()+++printOperationSetShowProgress ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_progress+    m ()+printOperationSetShowProgress _obj show_progress = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_progress' = (fromIntegral . fromEnum) show_progress+    gtk_print_operation_set_show_progress _obj' show_progress'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_support_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "support_selection", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "support_selection", 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 "gtk_print_operation_set_support_selection" gtk_print_operation_set_support_selection :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- support_selection : TBasicType TBoolean+    IO ()+++printOperationSetSupportSelection ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- support_selection+    m ()+printOperationSetSupportSelection _obj support_selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let support_selection' = (fromIntegral . fromEnum) support_selection+    gtk_print_operation_set_support_selection _obj' support_selection'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_track_print_status+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "track_status", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "track_status", 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 "gtk_print_operation_set_track_print_status" gtk_print_operation_set_track_print_status :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- track_status : TBasicType TBoolean+    IO ()+++printOperationSetTrackPrintStatus ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- track_status+    m ()+printOperationSetTrackPrintStatus _obj track_status = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let track_status' = (fromIntegral . fromEnum) track_status+    gtk_print_operation_set_track_print_status _obj' track_status'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_unit+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_operation_set_unit" gtk_print_operation_set_unit :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++printOperationSetUnit ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m ()+printOperationSetUnit _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    gtk_print_operation_set_unit _obj' unit'+    touchManagedPtr _obj+    return ()++-- method PrintOperation::set_use_full_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "full_page", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintOperation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "full_page", 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 "gtk_print_operation_set_use_full_page" gtk_print_operation_set_use_full_page :: +    Ptr PrintOperation ->                   -- _obj : TInterface "Gtk" "PrintOperation"+    CInt ->                                 -- full_page : TBasicType TBoolean+    IO ()+++printOperationSetUseFullPage ::+    (MonadIO m, PrintOperationK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- full_page+    m ()+printOperationSetUseFullPage _obj full_page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let full_page' = (fromIntegral . fromEnum) full_page+    gtk_print_operation_set_use_full_page _obj' full_page'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/PrintOperation.hs-boot view
@@ -0,0 +1,42 @@+module GI.Gtk.Objects.PrintOperation where++import Prelude ()+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 PrintOperation = PrintOperation (ForeignPtr PrintOperation)+instance GObject PrintOperation where+class GObject o => PrintOperationK o+instance (GObject o, IsDescendantOf PrintOperation o) => PrintOperationK o+data PrintOperationAllowAsyncPropertyInfo+data PrintOperationCurrentPagePropertyInfo+data PrintOperationCustomTabLabelPropertyInfo+data PrintOperationDefaultPageSetupPropertyInfo+data PrintOperationEmbedPageSetupPropertyInfo+data PrintOperationExportFilenamePropertyInfo+data PrintOperationHasSelectionPropertyInfo+data PrintOperationJobNamePropertyInfo+data PrintOperationNPagesPropertyInfo+data PrintOperationNPagesToPrintPropertyInfo+data PrintOperationPrintSettingsPropertyInfo+data PrintOperationShowProgressPropertyInfo+data PrintOperationStatusPropertyInfo+data PrintOperationStatusStringPropertyInfo+data PrintOperationSupportSelectionPropertyInfo+data PrintOperationTrackPrintStatusPropertyInfo+data PrintOperationUnitPropertyInfo+data PrintOperationUseFullPagePropertyInfo+data PrintOperationBeginPrintSignalInfo+data PrintOperationCreateCustomWidgetSignalInfo+data PrintOperationCustomWidgetApplySignalInfo+data PrintOperationDoneSignalInfo+data PrintOperationDrawPageSignalInfo+data PrintOperationEndPrintSignalInfo+data PrintOperationPaginateSignalInfo+data PrintOperationPreviewSignalInfo+data PrintOperationRequestPageSetupSignalInfo+data PrintOperationStatusChangedSignalInfo+data PrintOperationUpdateCustomWidgetSignalInfo
+ GI/Gtk/Objects/PrintSettings.hs view
@@ -0,0 +1,2430 @@++{- |+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.Gtk.Objects.PrintSettings+    ( ++-- * Exported types+    PrintSettings(..)                       ,+    PrintSettingsK                          ,+    toPrintSettings                         ,+    noPrintSettings                         ,+++ -- * Methods+-- ** printSettingsCopy+    printSettingsCopy                       ,+++-- ** printSettingsForeach+    printSettingsForeach                    ,+++-- ** printSettingsGet+    printSettingsGet                        ,+++-- ** printSettingsGetBool+    printSettingsGetBool                    ,+++-- ** printSettingsGetCollate+    printSettingsGetCollate                 ,+++-- ** printSettingsGetDefaultSource+    printSettingsGetDefaultSource           ,+++-- ** printSettingsGetDither+    printSettingsGetDither                  ,+++-- ** printSettingsGetDouble+    printSettingsGetDouble                  ,+++-- ** printSettingsGetDoubleWithDefault+    printSettingsGetDoubleWithDefault       ,+++-- ** printSettingsGetDuplex+    printSettingsGetDuplex                  ,+++-- ** printSettingsGetFinishings+    printSettingsGetFinishings              ,+++-- ** printSettingsGetInt+    printSettingsGetInt                     ,+++-- ** printSettingsGetIntWithDefault+    printSettingsGetIntWithDefault          ,+++-- ** printSettingsGetLength+    printSettingsGetLength                  ,+++-- ** printSettingsGetMediaType+    printSettingsGetMediaType               ,+++-- ** printSettingsGetNCopies+    printSettingsGetNCopies                 ,+++-- ** printSettingsGetNumberUp+    printSettingsGetNumberUp                ,+++-- ** printSettingsGetNumberUpLayout+    printSettingsGetNumberUpLayout          ,+++-- ** printSettingsGetOrientation+    printSettingsGetOrientation             ,+++-- ** printSettingsGetOutputBin+    printSettingsGetOutputBin               ,+++-- ** printSettingsGetPageRanges+    printSettingsGetPageRanges              ,+++-- ** printSettingsGetPageSet+    printSettingsGetPageSet                 ,+++-- ** printSettingsGetPaperHeight+    printSettingsGetPaperHeight             ,+++-- ** printSettingsGetPaperSize+    printSettingsGetPaperSize               ,+++-- ** printSettingsGetPaperWidth+    printSettingsGetPaperWidth              ,+++-- ** printSettingsGetPrintPages+    printSettingsGetPrintPages              ,+++-- ** printSettingsGetPrinter+    printSettingsGetPrinter                 ,+++-- ** printSettingsGetPrinterLpi+    printSettingsGetPrinterLpi              ,+++-- ** printSettingsGetQuality+    printSettingsGetQuality                 ,+++-- ** printSettingsGetResolution+    printSettingsGetResolution              ,+++-- ** printSettingsGetResolutionX+    printSettingsGetResolutionX             ,+++-- ** printSettingsGetResolutionY+    printSettingsGetResolutionY             ,+++-- ** printSettingsGetReverse+    printSettingsGetReverse                 ,+++-- ** printSettingsGetScale+    printSettingsGetScale                   ,+++-- ** printSettingsGetUseColor+    printSettingsGetUseColor                ,+++-- ** printSettingsHasKey+    printSettingsHasKey                     ,+++-- ** printSettingsLoadFile+    printSettingsLoadFile                   ,+++-- ** printSettingsLoadKeyFile+    printSettingsLoadKeyFile                ,+++-- ** printSettingsNew+    printSettingsNew                        ,+++-- ** printSettingsNewFromFile+    printSettingsNewFromFile                ,+++-- ** printSettingsNewFromKeyFile+    printSettingsNewFromKeyFile             ,+++-- ** printSettingsSet+    printSettingsSet                        ,+++-- ** printSettingsSetBool+    printSettingsSetBool                    ,+++-- ** printSettingsSetCollate+    printSettingsSetCollate                 ,+++-- ** printSettingsSetDefaultSource+    printSettingsSetDefaultSource           ,+++-- ** printSettingsSetDither+    printSettingsSetDither                  ,+++-- ** printSettingsSetDouble+    printSettingsSetDouble                  ,+++-- ** printSettingsSetDuplex+    printSettingsSetDuplex                  ,+++-- ** printSettingsSetFinishings+    printSettingsSetFinishings              ,+++-- ** printSettingsSetInt+    printSettingsSetInt                     ,+++-- ** printSettingsSetLength+    printSettingsSetLength                  ,+++-- ** printSettingsSetMediaType+    printSettingsSetMediaType               ,+++-- ** printSettingsSetNCopies+    printSettingsSetNCopies                 ,+++-- ** printSettingsSetNumberUp+    printSettingsSetNumberUp                ,+++-- ** printSettingsSetNumberUpLayout+    printSettingsSetNumberUpLayout          ,+++-- ** printSettingsSetOrientation+    printSettingsSetOrientation             ,+++-- ** printSettingsSetOutputBin+    printSettingsSetOutputBin               ,+++-- ** printSettingsSetPageRanges+    printSettingsSetPageRanges              ,+++-- ** printSettingsSetPageSet+    printSettingsSetPageSet                 ,+++-- ** printSettingsSetPaperHeight+    printSettingsSetPaperHeight             ,+++-- ** printSettingsSetPaperSize+    printSettingsSetPaperSize               ,+++-- ** printSettingsSetPaperWidth+    printSettingsSetPaperWidth              ,+++-- ** printSettingsSetPrintPages+    printSettingsSetPrintPages              ,+++-- ** printSettingsSetPrinter+    printSettingsSetPrinter                 ,+++-- ** printSettingsSetPrinterLpi+    printSettingsSetPrinterLpi              ,+++-- ** printSettingsSetQuality+    printSettingsSetQuality                 ,+++-- ** printSettingsSetResolution+    printSettingsSetResolution              ,+++-- ** printSettingsSetResolutionXy+    printSettingsSetResolutionXy            ,+++-- ** printSettingsSetReverse+    printSettingsSetReverse                 ,+++-- ** printSettingsSetScale+    printSettingsSetScale                   ,+++-- ** printSettingsSetUseColor+    printSettingsSetUseColor                ,+++-- ** printSettingsToFile+    printSettingsToFile                     ,+++-- ** printSettingsToKeyFile+    printSettingsToKeyFile                  ,+++-- ** printSettingsUnset+    printSettingsUnset                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype PrintSettings = PrintSettings (ForeignPtr PrintSettings)+foreign import ccall "gtk_print_settings_get_type"+    c_gtk_print_settings_get_type :: IO GType++type instance ParentTypes PrintSettings = PrintSettingsParentTypes+type PrintSettingsParentTypes = '[GObject.Object]++instance GObject PrintSettings where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_print_settings_get_type+    ++class GObject o => PrintSettingsK o+instance (GObject o, IsDescendantOf PrintSettings o) => PrintSettingsK o++toPrintSettings :: PrintSettingsK o => o -> IO PrintSettings+toPrintSettings = unsafeCastTo PrintSettings++noPrintSettings :: Maybe PrintSettings+noPrintSettings = Nothing++type instance AttributeList PrintSettings = PrintSettingsAttributeList+type PrintSettingsAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PrintSettings = PrintSettingsSignalList+type PrintSettingsSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PrintSettings::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "PrintSettings"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_new" gtk_print_settings_new :: +    IO (Ptr PrintSettings)+++printSettingsNew ::+    (MonadIO m) =>+    m PrintSettings+printSettingsNew  = liftIO $ do+    result <- gtk_print_settings_new+    checkUnexpectedReturnNULL "gtk_print_settings_new" result+    result' <- (wrapObject PrintSettings) result+    return result'++-- method PrintSettings::new_from_file+-- method type : Constructor+-- Args : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintSettings"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_settings_new_from_file" gtk_print_settings_new_from_file :: +    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PrintSettings)+++printSettingsNewFromFile ::+    (MonadIO m) =>+    [Char] ->                               -- file_name+    m PrintSettings+printSettingsNewFromFile file_name = liftIO $ do+    file_name' <- stringToCString file_name+    onException (do+        result <- propagateGError $ gtk_print_settings_new_from_file file_name'+        checkUnexpectedReturnNULL "gtk_print_settings_new_from_file" result+        result' <- (wrapObject PrintSettings) result+        freeMem file_name'+        return result'+     ) (do+        freeMem file_name'+     )++-- method PrintSettings::new_from_key_file+-- method type : Constructor+-- Args : [Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintSettings"+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_settings_new_from_key_file" gtk_print_settings_new_from_key_file :: +    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PrintSettings)+++printSettingsNewFromKeyFile ::+    (MonadIO m) =>+    GLib.KeyFile ->                         -- key_file+    Maybe (T.Text) ->                       -- group_name+    m PrintSettings+printSettingsNewFromKeyFile key_file group_name = liftIO $ do+    let key_file' = unsafeManagedPtrGetPtr key_file+    maybeGroup_name <- case group_name of+        Nothing -> return nullPtr+        Just jGroup_name -> do+            jGroup_name' <- textToCString jGroup_name+            return jGroup_name'+    onException (do+        result <- propagateGError $ gtk_print_settings_new_from_key_file key_file' maybeGroup_name+        checkUnexpectedReturnNULL "gtk_print_settings_new_from_key_file" result+        result' <- (wrapObject PrintSettings) result+        touchManagedPtr key_file+        freeMem maybeGroup_name+        return result'+     ) (do+        freeMem maybeGroup_name+     )++-- method PrintSettings::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintSettings"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_copy" gtk_print_settings_copy :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO (Ptr PrintSettings)+++printSettingsCopy ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PrintSettings+printSettingsCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_copy _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_copy" result+    result' <- (wrapObject PrintSettings) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "PrintSettingsFunc", 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 "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "func", argType = TInterface "Gtk" "PrintSettingsFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_foreach" gtk_print_settings_foreach :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    FunPtr PrintSettingsFuncC ->            -- func : TInterface "Gtk" "PrintSettingsFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++printSettingsForeach ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PrintSettingsFunc ->                    -- func+    m ()+printSettingsForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkPrintSettingsFunc (printSettingsFuncWrapper Nothing func)+    let user_data = nullPtr+    gtk_print_settings_foreach _obj' func' user_data+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::get+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_get" gtk_print_settings_get :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++printSettingsGet ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m T.Text+printSettingsGet _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_get _obj' key'+    checkUnexpectedReturnNULL "gtk_print_settings_get" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::get_bool+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_get_bool" gtk_print_settings_get_bool :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++printSettingsGetBool ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Bool+printSettingsGetBool _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_get_bool _obj' key'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::get_collate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_collate" gtk_print_settings_get_collate :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CInt+++printSettingsGetCollate ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Bool+printSettingsGetCollate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_collate _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_default_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_default_source" gtk_print_settings_get_default_source :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetDefaultSource ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetDefaultSource _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_default_source _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_default_source" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_dither+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_dither" gtk_print_settings_get_dither :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetDither ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetDither _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_dither _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_dither" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_double+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_get_double" gtk_print_settings_get_double :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO CDouble+++printSettingsGetDouble ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Double+printSettingsGetDouble _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_get_double _obj' key'+    let result' = realToFrac result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::get_double_with_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "def", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "def", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_double_with_default" gtk_print_settings_get_double_with_default :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CDouble ->                              -- def : TBasicType TDouble+    IO CDouble+++printSettingsGetDoubleWithDefault ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Double ->                               -- def+    m Double+printSettingsGetDoubleWithDefault _obj key def = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let def' = realToFrac def+    result <- gtk_print_settings_get_double_with_default _obj' key' def'+    let result' = realToFrac result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::get_duplex+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintDuplex"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_duplex" gtk_print_settings_get_duplex :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetDuplex ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PrintDuplex+printSettingsGetDuplex _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_duplex _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_finishings+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_finishings" gtk_print_settings_get_finishings :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetFinishings ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetFinishings _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_finishings _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_finishings" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_get_int" gtk_print_settings_get_int :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO Int32+++printSettingsGetInt ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Int32+printSettingsGetInt _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_get_int _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return result++-- method PrintSettings::get_int_with_default+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "def", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "def", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_int_with_default" gtk_print_settings_get_int_with_default :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    Int32 ->                                -- def : TBasicType TInt32+    IO Int32+++printSettingsGetIntWithDefault ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Int32 ->                                -- def+    m Int32+printSettingsGetIntWithDefault _obj key def = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_get_int_with_default _obj' key' def+    touchManagedPtr _obj+    freeMem key'+    return result++-- method PrintSettings::get_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_length" gtk_print_settings_get_length :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++printSettingsGetLength ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Unit ->                                 -- unit+    m Double+printSettingsGetLength _obj key unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_print_settings_get_length _obj' key' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::get_media_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_media_type" gtk_print_settings_get_media_type :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetMediaType ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetMediaType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_media_type _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_media_type" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_n_copies+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_n_copies" gtk_print_settings_get_n_copies :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO Int32+++printSettingsGetNCopies ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Int32+printSettingsGetNCopies _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_n_copies _obj'+    touchManagedPtr _obj+    return result++-- method PrintSettings::get_number_up+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_number_up" gtk_print_settings_get_number_up :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO Int32+++printSettingsGetNumberUp ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Int32+printSettingsGetNumberUp _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_number_up _obj'+    touchManagedPtr _obj+    return result++-- method PrintSettings::get_number_up_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "NumberUpLayout"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_number_up_layout" gtk_print_settings_get_number_up_layout :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetNumberUpLayout ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m NumberUpLayout+printSettingsGetNumberUpLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_number_up_layout _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageOrientation"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_orientation" gtk_print_settings_get_orientation :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetOrientation ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PageOrientation+printSettingsGetOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_output_bin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_output_bin" gtk_print_settings_get_output_bin :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetOutputBin ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetOutputBin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_output_bin _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_output_bin" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_page_ranges+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_ranges", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "num_ranges", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TInterface "Gtk" "PageRange")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_page_ranges" gtk_print_settings_get_page_ranges :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Ptr Int32 ->                            -- num_ranges : TBasicType TInt32+    IO (Ptr PageRange)+++printSettingsGetPageRanges ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m [PageRange]+printSettingsGetPageRanges _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    num_ranges <- allocMem :: IO (Ptr Int32)+    result <- gtk_print_settings_get_page_ranges _obj' num_ranges+    num_ranges' <- peek num_ranges+    checkUnexpectedReturnNULL "gtk_print_settings_get_page_ranges" result+    result' <- (unpackBlockArrayWithLength 8 num_ranges') result+    result'' <- mapM (wrapPtr PageRange) result'+    freeMem result+    touchManagedPtr _obj+    freeMem num_ranges+    return result''++-- method PrintSettings::get_page_set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PageSet"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_page_set" gtk_print_settings_get_page_set :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetPageSet ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PageSet+printSettingsGetPageSet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_page_set _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_paper_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_paper_height" gtk_print_settings_get_paper_height :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++printSettingsGetPaperHeight ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+printSettingsGetPaperHeight _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_print_settings_get_paper_height _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_paper_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PaperSize"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_paper_size" gtk_print_settings_get_paper_size :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO (Ptr PaperSize)+++printSettingsGetPaperSize ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PaperSize+printSettingsGetPaperSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_paper_size _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_paper_size" result+    result' <- (wrapBoxed PaperSize) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_paper_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_paper_width" gtk_print_settings_get_paper_width :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO CDouble+++printSettingsGetPaperWidth ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Unit ->                                 -- unit+    m Double+printSettingsGetPaperWidth _obj unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let unit' = (fromIntegral . fromEnum) unit+    result <- gtk_print_settings_get_paper_width _obj' unit'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_print_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintPages"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_print_pages" gtk_print_settings_get_print_pages :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetPrintPages ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PrintPages+printSettingsGetPrintPages _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_print_pages _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_printer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_printer" gtk_print_settings_get_printer :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CString+++printSettingsGetPrinter ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m T.Text+printSettingsGetPrinter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_printer _obj'+    checkUnexpectedReturnNULL "gtk_print_settings_get_printer" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_printer_lpi+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_printer_lpi" gtk_print_settings_get_printer_lpi :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CDouble+++printSettingsGetPrinterLpi ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Double+printSettingsGetPrinterLpi _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_printer_lpi _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_quality+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "PrintQuality"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_quality" gtk_print_settings_get_quality :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CUInt+++printSettingsGetQuality ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m PrintQuality+printSettingsGetQuality _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_quality _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_resolution+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_resolution" gtk_print_settings_get_resolution :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO Int32+++printSettingsGetResolution ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Int32+printSettingsGetResolution _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_resolution _obj'+    touchManagedPtr _obj+    return result++-- method PrintSettings::get_resolution_x+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_resolution_x" gtk_print_settings_get_resolution_x :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO Int32+++printSettingsGetResolutionX ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Int32+printSettingsGetResolutionX _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_resolution_x _obj'+    touchManagedPtr _obj+    return result++-- method PrintSettings::get_resolution_y+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_resolution_y" gtk_print_settings_get_resolution_y :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO Int32+++printSettingsGetResolutionY ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Int32+printSettingsGetResolutionY _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_resolution_y _obj'+    touchManagedPtr _obj+    return result++-- method PrintSettings::get_reverse+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_reverse" gtk_print_settings_get_reverse :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CInt+++printSettingsGetReverse ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Bool+printSettingsGetReverse _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_reverse _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_scale" gtk_print_settings_get_scale :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CDouble+++printSettingsGetScale ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Double+printSettingsGetScale _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_scale _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::get_use_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_get_use_color" gtk_print_settings_get_use_color :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    IO CInt+++printSettingsGetUseColor ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    m Bool+printSettingsGetUseColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_print_settings_get_use_color _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method PrintSettings::has_key+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_has_key" gtk_print_settings_has_key :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO CInt+++printSettingsHasKey ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m Bool+printSettingsHasKey _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gtk_print_settings_has_key _obj' key'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem key'+    return result'++-- method PrintSettings::load_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_settings_load_file" gtk_print_settings_load_file :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++printSettingsLoadFile ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- file_name+    m ()+printSettingsLoadFile _obj file_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    file_name' <- stringToCString file_name+    onException (do+        _ <- propagateGError $ gtk_print_settings_load_file _obj' file_name'+        touchManagedPtr _obj+        freeMem file_name'+        return ()+     ) (do+        freeMem file_name'+     )++-- method PrintSettings::load_key_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", 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 "gtk_print_settings_load_key_file" gtk_print_settings_load_key_file :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++printSettingsLoadKeyFile ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    GLib.KeyFile ->                         -- key_file+    Maybe (T.Text) ->                       -- group_name+    m ()+printSettingsLoadKeyFile _obj key_file group_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let key_file' = unsafeManagedPtrGetPtr key_file+    maybeGroup_name <- case group_name of+        Nothing -> return nullPtr+        Just jGroup_name -> do+            jGroup_name' <- textToCString jGroup_name+            return jGroup_name'+    onException (do+        _ <- propagateGError $ gtk_print_settings_load_key_file _obj' key_file' maybeGroup_name+        touchManagedPtr _obj+        touchManagedPtr key_file+        freeMem maybeGroup_name+        return ()+     ) (do+        freeMem maybeGroup_name+     )++-- method PrintSettings::set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set" gtk_print_settings_set :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++printSettingsSet ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Maybe (T.Text) ->                       -- value+    m ()+printSettingsSet _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            jValue' <- textToCString jValue+            return jValue'+    gtk_print_settings_set _obj' key' maybeValue+    touchManagedPtr _obj+    freeMem key'+    freeMem maybeValue+    return ()++-- method PrintSettings::set_bool+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_bool" gtk_print_settings_set_bool :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CInt ->                                 -- value : TBasicType TBoolean+    IO ()+++printSettingsSetBool ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Bool ->                                 -- value+    m ()+printSettingsSetBool _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = (fromIntegral . fromEnum) value+    gtk_print_settings_set_bool _obj' key' value'+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method PrintSettings::set_collate+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "collate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "collate", 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 "gtk_print_settings_set_collate" gtk_print_settings_set_collate :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CInt ->                                 -- collate : TBasicType TBoolean+    IO ()+++printSettingsSetCollate ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- collate+    m ()+printSettingsSetCollate _obj collate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let collate' = (fromIntegral . fromEnum) collate+    gtk_print_settings_set_collate _obj' collate'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_default_source+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "default_source", 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 "gtk_print_settings_set_default_source" gtk_print_settings_set_default_source :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- default_source : TBasicType TUTF8+    IO ()+++printSettingsSetDefaultSource ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- default_source+    m ()+printSettingsSetDefaultSource _obj default_source = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    default_source' <- textToCString default_source+    gtk_print_settings_set_default_source _obj' default_source'+    touchManagedPtr _obj+    freeMem default_source'+    return ()++-- method PrintSettings::set_dither+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dither", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "dither", 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 "gtk_print_settings_set_dither" gtk_print_settings_set_dither :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- dither : TBasicType TUTF8+    IO ()+++printSettingsSetDither ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- dither+    m ()+printSettingsSetDither _obj dither = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    dither' <- textToCString dither+    gtk_print_settings_set_dither _obj' dither'+    touchManagedPtr _obj+    freeMem dither'+    return ()++-- method PrintSettings::set_double+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_double" gtk_print_settings_set_double :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++printSettingsSetDouble ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Double ->                               -- value+    m ()+printSettingsSetDouble _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = realToFrac value+    gtk_print_settings_set_double _obj' key' value'+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method PrintSettings::set_duplex+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "duplex", argType = TInterface "Gtk" "PrintDuplex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "duplex", argType = TInterface "Gtk" "PrintDuplex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_duplex" gtk_print_settings_set_duplex :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- duplex : TInterface "Gtk" "PrintDuplex"+    IO ()+++printSettingsSetDuplex ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PrintDuplex ->                          -- duplex+    m ()+printSettingsSetDuplex _obj duplex = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let duplex' = (fromIntegral . fromEnum) duplex+    gtk_print_settings_set_duplex _obj' duplex'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_finishings+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "finishings", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "finishings", 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 "gtk_print_settings_set_finishings" gtk_print_settings_set_finishings :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- finishings : TBasicType TUTF8+    IO ()+++printSettingsSetFinishings ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- finishings+    m ()+printSettingsSetFinishings _obj finishings = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    finishings' <- textToCString finishings+    gtk_print_settings_set_finishings _obj' finishings'+    touchManagedPtr _obj+    freeMem finishings'+    return ()++-- method PrintSettings::set_int+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_int" gtk_print_settings_set_int :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt32+    IO ()+++printSettingsSetInt ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Int32 ->                                -- value+    m ()+printSettingsSetInt _obj key value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    gtk_print_settings_set_int _obj' key' value+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method PrintSettings::set_length+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_length" gtk_print_settings_set_length :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    CDouble ->                              -- value : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++printSettingsSetLength ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    Double ->                               -- value+    Unit ->                                 -- unit+    m ()+printSettingsSetLength _obj key value unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    let value' = realToFrac value+    let unit' = (fromIntegral . fromEnum) unit+    gtk_print_settings_set_length _obj' key' value' unit'+    touchManagedPtr _obj+    freeMem key'+    return ()++-- method PrintSettings::set_media_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "media_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "media_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 "gtk_print_settings_set_media_type" gtk_print_settings_set_media_type :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- media_type : TBasicType TUTF8+    IO ()+++printSettingsSetMediaType ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- media_type+    m ()+printSettingsSetMediaType _obj media_type = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    media_type' <- textToCString media_type+    gtk_print_settings_set_media_type _obj' media_type'+    touchManagedPtr _obj+    freeMem media_type'+    return ()++-- method PrintSettings::set_n_copies+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_copies", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_copies", 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 "gtk_print_settings_set_n_copies" gtk_print_settings_set_n_copies :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Int32 ->                                -- num_copies : TBasicType TInt32+    IO ()+++printSettingsSetNCopies ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- num_copies+    m ()+printSettingsSetNCopies _obj num_copies = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_settings_set_n_copies _obj' num_copies+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_number_up+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_up", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_up", 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 "gtk_print_settings_set_number_up" gtk_print_settings_set_number_up :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Int32 ->                                -- number_up : TBasicType TInt32+    IO ()+++printSettingsSetNumberUp ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- number_up+    m ()+printSettingsSetNumberUp _obj number_up = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_settings_set_number_up _obj' number_up+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_number_up_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_up_layout", argType = TInterface "Gtk" "NumberUpLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "number_up_layout", argType = TInterface "Gtk" "NumberUpLayout", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_number_up_layout" gtk_print_settings_set_number_up_layout :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- number_up_layout : TInterface "Gtk" "NumberUpLayout"+    IO ()+++printSettingsSetNumberUpLayout ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    NumberUpLayout ->                       -- number_up_layout+    m ()+printSettingsSetNumberUpLayout _obj number_up_layout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let number_up_layout' = (fromIntegral . fromEnum) number_up_layout+    gtk_print_settings_set_number_up_layout _obj' number_up_layout'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "PageOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "orientation", argType = TInterface "Gtk" "PageOrientation", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_orientation" gtk_print_settings_set_orientation :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- orientation : TInterface "Gtk" "PageOrientation"+    IO ()+++printSettingsSetOrientation ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PageOrientation ->                      -- orientation+    m ()+printSettingsSetOrientation _obj orientation = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let orientation' = (fromIntegral . fromEnum) orientation+    gtk_print_settings_set_orientation _obj' orientation'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_output_bin+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "output_bin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "output_bin", 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 "gtk_print_settings_set_output_bin" gtk_print_settings_set_output_bin :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- output_bin : TBasicType TUTF8+    IO ()+++printSettingsSetOutputBin ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- output_bin+    m ()+printSettingsSetOutputBin _obj output_bin = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    output_bin' <- textToCString output_bin+    gtk_print_settings_set_output_bin _obj' output_bin'+    touchManagedPtr _obj+    freeMem output_bin'+    return ()++-- method PrintSettings::set_page_ranges+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_ranges", argType = TCArray False (-1) 2 (TInterface "Gtk" "PageRange"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "num_ranges", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : [Arg {argName = "num_ranges", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_ranges", argType = TCArray False (-1) 2 (TInterface "Gtk" "PageRange"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_page_ranges" gtk_print_settings_set_page_ranges :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Ptr PageRange ->                        -- page_ranges : TCArray False (-1) 2 (TInterface "Gtk" "PageRange")+    Int32 ->                                -- num_ranges : TBasicType TInt32+    IO ()+++printSettingsSetPageRanges ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    [PageRange] ->                          -- page_ranges+    m ()+printSettingsSetPageRanges _obj page_ranges = liftIO $ do+    let num_ranges = fromIntegral $ length page_ranges+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page_ranges' = map unsafeManagedPtrGetPtr page_ranges+    page_ranges'' <- packBlockArray 8 page_ranges'+    gtk_print_settings_set_page_ranges _obj' page_ranges'' num_ranges+    touchManagedPtr _obj+    mapM_ touchManagedPtr page_ranges+    freeMem page_ranges''+    return ()++-- method PrintSettings::set_page_set+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_set", argType = TInterface "Gtk" "PageSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page_set", argType = TInterface "Gtk" "PageSet", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_page_set" gtk_print_settings_set_page_set :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- page_set : TInterface "Gtk" "PageSet"+    IO ()+++printSettingsSetPageSet ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PageSet ->                              -- page_set+    m ()+printSettingsSetPageSet _obj page_set = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let page_set' = (fromIntegral . fromEnum) page_set+    gtk_print_settings_set_page_set _obj' page_set'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_paper_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_paper_height" gtk_print_settings_set_paper_height :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CDouble ->                              -- height : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++printSettingsSetPaperHeight ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Double ->                               -- height+    Unit ->                                 -- unit+    m ()+printSettingsSetPaperHeight _obj height unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let height' = realToFrac height+    let unit' = (fromIntegral . fromEnum) unit+    gtk_print_settings_set_paper_height _obj' height' unit'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_paper_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paper_size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paper_size", argType = TInterface "Gtk" "PaperSize", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_paper_size" gtk_print_settings_set_paper_size :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Ptr PaperSize ->                        -- paper_size : TInterface "Gtk" "PaperSize"+    IO ()+++printSettingsSetPaperSize ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PaperSize ->                            -- paper_size+    m ()+printSettingsSetPaperSize _obj paper_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let paper_size' = unsafeManagedPtrGetPtr paper_size+    gtk_print_settings_set_paper_size _obj' paper_size'+    touchManagedPtr _obj+    touchManagedPtr paper_size+    return ()++-- method PrintSettings::set_paper_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "unit", argType = TInterface "Gtk" "Unit", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_paper_width" gtk_print_settings_set_paper_width :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CDouble ->                              -- width : TBasicType TDouble+    CUInt ->                                -- unit : TInterface "Gtk" "Unit"+    IO ()+++printSettingsSetPaperWidth ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Double ->                               -- width+    Unit ->                                 -- unit+    m ()+printSettingsSetPaperWidth _obj width unit = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let width' = realToFrac width+    let unit' = (fromIntegral . fromEnum) unit+    gtk_print_settings_set_paper_width _obj' width' unit'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_print_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pages", argType = TInterface "Gtk" "PrintPages", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "pages", argType = TInterface "Gtk" "PrintPages", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_print_pages" gtk_print_settings_set_print_pages :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- pages : TInterface "Gtk" "PrintPages"+    IO ()+++printSettingsSetPrintPages ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PrintPages ->                           -- pages+    m ()+printSettingsSetPrintPages _obj pages = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pages' = (fromIntegral . fromEnum) pages+    gtk_print_settings_set_print_pages _obj' pages'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_printer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "printer", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "printer", 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 "gtk_print_settings_set_printer" gtk_print_settings_set_printer :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- printer : TBasicType TUTF8+    IO ()+++printSettingsSetPrinter ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- printer+    m ()+printSettingsSetPrinter _obj printer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    printer' <- textToCString printer+    gtk_print_settings_set_printer _obj' printer'+    touchManagedPtr _obj+    freeMem printer'+    return ()++-- method PrintSettings::set_printer_lpi+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lpi", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "lpi", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_printer_lpi" gtk_print_settings_set_printer_lpi :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CDouble ->                              -- lpi : TBasicType TDouble+    IO ()+++printSettingsSetPrinterLpi ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Double ->                               -- lpi+    m ()+printSettingsSetPrinterLpi _obj lpi = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let lpi' = realToFrac lpi+    gtk_print_settings_set_printer_lpi _obj' lpi'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_quality+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quality", argType = TInterface "Gtk" "PrintQuality", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quality", argType = TInterface "Gtk" "PrintQuality", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_quality" gtk_print_settings_set_quality :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CUInt ->                                -- quality : TInterface "Gtk" "PrintQuality"+    IO ()+++printSettingsSetQuality ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    PrintQuality ->                         -- quality+    m ()+printSettingsSetQuality _obj quality = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let quality' = (fromIntegral . fromEnum) quality+    gtk_print_settings_set_quality _obj' quality'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_resolution+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution", 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 "gtk_print_settings_set_resolution" gtk_print_settings_set_resolution :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Int32 ->                                -- resolution : TBasicType TInt32+    IO ()+++printSettingsSetResolution ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- resolution+    m ()+printSettingsSetResolution _obj resolution = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_settings_set_resolution _obj' resolution+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_resolution_xy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution_y", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution_x", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "resolution_y", 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 "gtk_print_settings_set_resolution_xy" gtk_print_settings_set_resolution_xy :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Int32 ->                                -- resolution_x : TBasicType TInt32+    Int32 ->                                -- resolution_y : TBasicType TInt32+    IO ()+++printSettingsSetResolutionXy ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- resolution_x+    Int32 ->                                -- resolution_y+    m ()+printSettingsSetResolutionXy _obj resolution_x resolution_y = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_print_settings_set_resolution_xy _obj' resolution_x resolution_y+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_reverse+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reverse", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "reverse", 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 "gtk_print_settings_set_reverse" gtk_print_settings_set_reverse :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CInt ->                                 -- reverse : TBasicType TBoolean+    IO ()+++printSettingsSetReverse ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- reverse+    m ()+printSettingsSetReverse _obj reverse = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let reverse' = (fromIntegral . fromEnum) reverse+    gtk_print_settings_set_reverse _obj' reverse'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_scale+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_print_settings_set_scale" gtk_print_settings_set_scale :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CDouble ->                              -- scale : TBasicType TDouble+    IO ()+++printSettingsSetScale ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Double ->                               -- scale+    m ()+printSettingsSetScale _obj scale = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let scale' = realToFrac scale+    gtk_print_settings_set_scale _obj' scale'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::set_use_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_color", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "use_color", 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 "gtk_print_settings_set_use_color" gtk_print_settings_set_use_color :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CInt ->                                 -- use_color : TBasicType TBoolean+    IO ()+++printSettingsSetUseColor ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- use_color+    m ()+printSettingsSetUseColor _obj use_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let use_color' = (fromIntegral . fromEnum) use_color+    gtk_print_settings_set_use_color _obj' use_color'+    touchManagedPtr _obj+    return ()++-- method PrintSettings::to_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "file_name", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gtk_print_settings_to_file" gtk_print_settings_to_file :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- file_name : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++printSettingsToFile ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    [Char] ->                               -- file_name+    m ()+printSettingsToFile _obj file_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    file_name' <- stringToCString file_name+    onException (do+        _ <- propagateGError $ gtk_print_settings_to_file _obj' file_name'+        touchManagedPtr _obj+        freeMem file_name'+        return ()+     ) (do+        freeMem file_name'+     )++-- method PrintSettings::to_key_file+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "key_file", argType = TInterface "GLib" "KeyFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_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 "gtk_print_settings_to_key_file" gtk_print_settings_to_key_file :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    Ptr GLib.KeyFile ->                     -- key_file : TInterface "GLib" "KeyFile"+    CString ->                              -- group_name : TBasicType TUTF8+    IO ()+++printSettingsToKeyFile ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    GLib.KeyFile ->                         -- key_file+    T.Text ->                               -- group_name+    m ()+printSettingsToKeyFile _obj key_file group_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let key_file' = unsafeManagedPtrGetPtr key_file+    group_name' <- textToCString group_name+    gtk_print_settings_to_key_file _obj' key_file' group_name'+    touchManagedPtr _obj+    touchManagedPtr key_file+    freeMem group_name'+    return ()++-- method PrintSettings::unset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "PrintSettings", 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 "Gtk" "PrintSettings", 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 "gtk_print_settings_unset" gtk_print_settings_unset :: +    Ptr PrintSettings ->                    -- _obj : TInterface "Gtk" "PrintSettings"+    CString ->                              -- key : TBasicType TUTF8+    IO ()+++printSettingsUnset ::+    (MonadIO m, PrintSettingsK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- key+    m ()+printSettingsUnset _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    gtk_print_settings_unset _obj' key'+    touchManagedPtr _obj+    freeMem key'+    return ()++
+ GI/Gtk/Objects/PrintSettings.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.PrintSettings where++import Prelude ()+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 PrintSettings = PrintSettings (ForeignPtr PrintSettings)+instance GObject PrintSettings where+class GObject o => PrintSettingsK o+instance (GObject o, IsDescendantOf PrintSettings o) => PrintSettingsK o
+ GI/Gtk/Objects/ProgressBar.hs view
@@ -0,0 +1,672 @@++{- |+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.Gtk.Objects.ProgressBar+    ( ++-- * Exported types+    ProgressBar(..)                         ,+    ProgressBarK                            ,+    toProgressBar                           ,+    noProgressBar                           ,+++ -- * Methods+-- ** progressBarGetEllipsize+    progressBarGetEllipsize                 ,+++-- ** progressBarGetFraction+    progressBarGetFraction                  ,+++-- ** progressBarGetInverted+    progressBarGetInverted                  ,+++-- ** progressBarGetPulseStep+    progressBarGetPulseStep                 ,+++-- ** progressBarGetShowText+    progressBarGetShowText                  ,+++-- ** progressBarGetText+    progressBarGetText                      ,+++-- ** progressBarNew+    progressBarNew                          ,+++-- ** progressBarPulse+    progressBarPulse                        ,+++-- ** progressBarSetEllipsize+    progressBarSetEllipsize                 ,+++-- ** progressBarSetFraction+    progressBarSetFraction                  ,+++-- ** progressBarSetInverted+    progressBarSetInverted                  ,+++-- ** progressBarSetPulseStep+    progressBarSetPulseStep                 ,+++-- ** progressBarSetShowText+    progressBarSetShowText                  ,+++-- ** progressBarSetText+    progressBarSetText                      ,+++++ -- * Properties+-- ** Ellipsize+    ProgressBarEllipsizePropertyInfo        ,+    constructProgressBarEllipsize           ,+    getProgressBarEllipsize                 ,+    setProgressBarEllipsize                 ,+++-- ** Fraction+    ProgressBarFractionPropertyInfo         ,+    constructProgressBarFraction            ,+    getProgressBarFraction                  ,+    setProgressBarFraction                  ,+++-- ** Inverted+    ProgressBarInvertedPropertyInfo         ,+    constructProgressBarInverted            ,+    getProgressBarInverted                  ,+    setProgressBarInverted                  ,+++-- ** PulseStep+    ProgressBarPulseStepPropertyInfo        ,+    constructProgressBarPulseStep           ,+    getProgressBarPulseStep                 ,+    setProgressBarPulseStep                 ,+++-- ** ShowText+    ProgressBarShowTextPropertyInfo         ,+    constructProgressBarShowText            ,+    getProgressBarShowText                  ,+    setProgressBarShowText                  ,+++-- ** Text+    ProgressBarTextPropertyInfo             ,+    constructProgressBarText                ,+    getProgressBarText                      ,+    setProgressBarText                      ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Pango as Pango++newtype ProgressBar = ProgressBar (ForeignPtr ProgressBar)+foreign import ccall "gtk_progress_bar_get_type"+    c_gtk_progress_bar_get_type :: IO GType++type instance ParentTypes ProgressBar = ProgressBarParentTypes+type ProgressBarParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject ProgressBar where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_progress_bar_get_type+    ++class GObject o => ProgressBarK o+instance (GObject o, IsDescendantOf ProgressBar o) => ProgressBarK o++toProgressBar :: ProgressBarK o => o -> IO ProgressBar+toProgressBar = unsafeCastTo ProgressBar++noProgressBar :: Maybe ProgressBar+noProgressBar = Nothing++-- VVV Prop "ellipsize"+   -- Type: TInterface "Pango" "EllipsizeMode"+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarEllipsize :: (MonadIO m, ProgressBarK o) => o -> m Pango.EllipsizeMode+getProgressBarEllipsize obj = liftIO $ getObjectPropertyEnum obj "ellipsize"++setProgressBarEllipsize :: (MonadIO m, ProgressBarK o) => o -> Pango.EllipsizeMode -> m ()+setProgressBarEllipsize obj val = liftIO $ setObjectPropertyEnum obj "ellipsize" val++constructProgressBarEllipsize :: Pango.EllipsizeMode -> IO ([Char], GValue)+constructProgressBarEllipsize val = constructObjectPropertyEnum "ellipsize" val++data ProgressBarEllipsizePropertyInfo+instance AttrInfo ProgressBarEllipsizePropertyInfo where+    type AttrAllowedOps ProgressBarEllipsizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarEllipsizePropertyInfo = (~) Pango.EllipsizeMode+    type AttrBaseTypeConstraint ProgressBarEllipsizePropertyInfo = ProgressBarK+    type AttrGetType ProgressBarEllipsizePropertyInfo = Pango.EllipsizeMode+    type AttrLabel ProgressBarEllipsizePropertyInfo = "ProgressBar::ellipsize"+    attrGet _ = getProgressBarEllipsize+    attrSet _ = setProgressBarEllipsize+    attrConstruct _ = constructProgressBarEllipsize++-- VVV Prop "fraction"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarFraction :: (MonadIO m, ProgressBarK o) => o -> m Double+getProgressBarFraction obj = liftIO $ getObjectPropertyDouble obj "fraction"++setProgressBarFraction :: (MonadIO m, ProgressBarK o) => o -> Double -> m ()+setProgressBarFraction obj val = liftIO $ setObjectPropertyDouble obj "fraction" val++constructProgressBarFraction :: Double -> IO ([Char], GValue)+constructProgressBarFraction val = constructObjectPropertyDouble "fraction" val++data ProgressBarFractionPropertyInfo+instance AttrInfo ProgressBarFractionPropertyInfo where+    type AttrAllowedOps ProgressBarFractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarFractionPropertyInfo = (~) Double+    type AttrBaseTypeConstraint ProgressBarFractionPropertyInfo = ProgressBarK+    type AttrGetType ProgressBarFractionPropertyInfo = Double+    type AttrLabel ProgressBarFractionPropertyInfo = "ProgressBar::fraction"+    attrGet _ = getProgressBarFraction+    attrSet _ = setProgressBarFraction+    attrConstruct _ = constructProgressBarFraction++-- VVV Prop "inverted"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarInverted :: (MonadIO m, ProgressBarK o) => o -> m Bool+getProgressBarInverted obj = liftIO $ getObjectPropertyBool obj "inverted"++setProgressBarInverted :: (MonadIO m, ProgressBarK o) => o -> Bool -> m ()+setProgressBarInverted obj val = liftIO $ setObjectPropertyBool obj "inverted" val++constructProgressBarInverted :: Bool -> IO ([Char], GValue)+constructProgressBarInverted val = constructObjectPropertyBool "inverted" val++data ProgressBarInvertedPropertyInfo+instance AttrInfo ProgressBarInvertedPropertyInfo where+    type AttrAllowedOps ProgressBarInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarInvertedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ProgressBarInvertedPropertyInfo = ProgressBarK+    type AttrGetType ProgressBarInvertedPropertyInfo = Bool+    type AttrLabel ProgressBarInvertedPropertyInfo = "ProgressBar::inverted"+    attrGet _ = getProgressBarInverted+    attrSet _ = setProgressBarInverted+    attrConstruct _ = constructProgressBarInverted++-- VVV Prop "pulse-step"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarPulseStep :: (MonadIO m, ProgressBarK o) => o -> m Double+getProgressBarPulseStep obj = liftIO $ getObjectPropertyDouble obj "pulse-step"++setProgressBarPulseStep :: (MonadIO m, ProgressBarK o) => o -> Double -> m ()+setProgressBarPulseStep obj val = liftIO $ setObjectPropertyDouble obj "pulse-step" val++constructProgressBarPulseStep :: Double -> IO ([Char], GValue)+constructProgressBarPulseStep val = constructObjectPropertyDouble "pulse-step" val++data ProgressBarPulseStepPropertyInfo+instance AttrInfo ProgressBarPulseStepPropertyInfo where+    type AttrAllowedOps ProgressBarPulseStepPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarPulseStepPropertyInfo = (~) Double+    type AttrBaseTypeConstraint ProgressBarPulseStepPropertyInfo = ProgressBarK+    type AttrGetType ProgressBarPulseStepPropertyInfo = Double+    type AttrLabel ProgressBarPulseStepPropertyInfo = "ProgressBar::pulse-step"+    attrGet _ = getProgressBarPulseStep+    attrSet _ = setProgressBarPulseStep+    attrConstruct _ = constructProgressBarPulseStep++-- VVV Prop "show-text"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarShowText :: (MonadIO m, ProgressBarK o) => o -> m Bool+getProgressBarShowText obj = liftIO $ getObjectPropertyBool obj "show-text"++setProgressBarShowText :: (MonadIO m, ProgressBarK o) => o -> Bool -> m ()+setProgressBarShowText obj val = liftIO $ setObjectPropertyBool obj "show-text" val++constructProgressBarShowText :: Bool -> IO ([Char], GValue)+constructProgressBarShowText val = constructObjectPropertyBool "show-text" val++data ProgressBarShowTextPropertyInfo+instance AttrInfo ProgressBarShowTextPropertyInfo where+    type AttrAllowedOps ProgressBarShowTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarShowTextPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint ProgressBarShowTextPropertyInfo = ProgressBarK+    type AttrGetType ProgressBarShowTextPropertyInfo = Bool+    type AttrLabel ProgressBarShowTextPropertyInfo = "ProgressBar::show-text"+    attrGet _ = getProgressBarShowText+    attrSet _ = setProgressBarShowText+    attrConstruct _ = constructProgressBarShowText++-- VVV Prop "text"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable]++getProgressBarText :: (MonadIO m, ProgressBarK o) => o -> m T.Text+getProgressBarText obj = liftIO $ getObjectPropertyString obj "text"++setProgressBarText :: (MonadIO m, ProgressBarK o) => o -> T.Text -> m ()+setProgressBarText obj val = liftIO $ setObjectPropertyString obj "text" val++constructProgressBarText :: T.Text -> IO ([Char], GValue)+constructProgressBarText val = constructObjectPropertyString "text" val++data ProgressBarTextPropertyInfo+instance AttrInfo ProgressBarTextPropertyInfo where+    type AttrAllowedOps ProgressBarTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ProgressBarTextPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ProgressBarTextPropertyInfo = ProgressBarK+    type AttrGetType ProgressBarTextPropertyInfo = T.Text+    type AttrLabel ProgressBarTextPropertyInfo = "ProgressBar::text"+    attrGet _ = getProgressBarText+    attrSet _ = setProgressBarText+    attrConstruct _ = constructProgressBarText++type instance AttributeList ProgressBar = ProgressBarAttributeList+type ProgressBarAttributeList = ('[ '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("ellipsize", ProgressBarEllipsizePropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("fraction", ProgressBarFractionPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inverted", ProgressBarInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("pulse-step", ProgressBarPulseStepPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-text", ProgressBarShowTextPropertyInfo), '("style", WidgetStylePropertyInfo), '("text", ProgressBarTextPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ProgressBar = ProgressBarSignalList+type ProgressBarSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ProgressBar::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "ProgressBar"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_new" gtk_progress_bar_new :: +    IO (Ptr ProgressBar)+++progressBarNew ::+    (MonadIO m) =>+    m ProgressBar+progressBarNew  = liftIO $ do+    result <- gtk_progress_bar_new+    checkUnexpectedReturnNULL "gtk_progress_bar_new" result+    result' <- (newObject ProgressBar) result+    return result'++-- method ProgressBar::get_ellipsize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Pango" "EllipsizeMode"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_ellipsize" gtk_progress_bar_get_ellipsize :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CUInt+++progressBarGetEllipsize ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m Pango.EllipsizeMode+progressBarGetEllipsize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_ellipsize _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::get_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_fraction" gtk_progress_bar_get_fraction :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CDouble+++progressBarGetFraction ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m Double+progressBarGetFraction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_fraction _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::get_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_inverted" gtk_progress_bar_get_inverted :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CInt+++progressBarGetInverted ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m Bool+progressBarGetInverted _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_inverted _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::get_pulse_step+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_pulse_step" gtk_progress_bar_get_pulse_step :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CDouble+++progressBarGetPulseStep ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m Double+progressBarGetPulseStep _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_pulse_step _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::get_show_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_show_text" gtk_progress_bar_get_show_text :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CInt+++progressBarGetShowText ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m Bool+progressBarGetShowText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_show_text _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_get_text" gtk_progress_bar_get_text :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO CString+++progressBarGetText ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m T.Text+progressBarGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_progress_bar_get_text _obj'+    checkUnexpectedReturnNULL "gtk_progress_bar_get_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method ProgressBar::pulse+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_pulse" gtk_progress_bar_pulse :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    IO ()+++progressBarPulse ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    m ()+progressBarPulse _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_progress_bar_pulse _obj'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_ellipsize+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Pango" "EllipsizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "mode", argType = TInterface "Pango" "EllipsizeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_set_ellipsize" gtk_progress_bar_set_ellipsize :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CUInt ->                                -- mode : TInterface "Pango" "EllipsizeMode"+    IO ()+++progressBarSetEllipsize ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Pango.EllipsizeMode ->                  -- mode+    m ()+progressBarSetEllipsize _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gtk_progress_bar_set_ellipsize _obj' mode'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_set_fraction" gtk_progress_bar_set_fraction :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CDouble ->                              -- fraction : TBasicType TDouble+    IO ()+++progressBarSetFraction ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Double ->                               -- fraction+    m ()+progressBarSetFraction _obj fraction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fraction' = realToFrac fraction+    gtk_progress_bar_set_fraction _obj' fraction'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", 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 "Gtk" "ProgressBar", 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 "gtk_progress_bar_set_inverted" gtk_progress_bar_set_inverted :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CInt ->                                 -- inverted : TBasicType TBoolean+    IO ()+++progressBarSetInverted ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- inverted+    m ()+progressBarSetInverted _obj inverted = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let inverted' = (fromIntegral . fromEnum) inverted+    gtk_progress_bar_set_inverted _obj' inverted'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_pulse_step+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fraction", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_progress_bar_set_pulse_step" gtk_progress_bar_set_pulse_step :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CDouble ->                              -- fraction : TBasicType TDouble+    IO ()+++progressBarSetPulseStep ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Double ->                               -- fraction+    m ()+progressBarSetPulseStep _obj fraction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fraction' = realToFrac fraction+    gtk_progress_bar_set_pulse_step _obj' fraction'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_show_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_text", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_text", 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 "gtk_progress_bar_set_show_text" gtk_progress_bar_set_show_text :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CInt ->                                 -- show_text : TBasicType TBoolean+    IO ()+++progressBarSetShowText ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_text+    m ()+progressBarSetShowText _obj show_text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_text' = (fromIntegral . fromEnum) show_text+    gtk_progress_bar_set_show_text _obj' show_text'+    touchManagedPtr _obj+    return ()++-- method ProgressBar::set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "ProgressBar", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", 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 "gtk_progress_bar_set_text" gtk_progress_bar_set_text :: +    Ptr ProgressBar ->                      -- _obj : TInterface "Gtk" "ProgressBar"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++progressBarSetText ::+    (MonadIO m, ProgressBarK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- text+    m ()+progressBarSetText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeText <- case text of+        Nothing -> return nullPtr+        Just jText -> do+            jText' <- textToCString jText+            return jText'+    gtk_progress_bar_set_text _obj' maybeText+    touchManagedPtr _obj+    freeMem maybeText+    return ()++
+ GI/Gtk/Objects/ProgressBar.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gtk.Objects.ProgressBar where++import Prelude ()+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 ProgressBar = ProgressBar (ForeignPtr ProgressBar)+instance GObject ProgressBar where+class GObject o => ProgressBarK o+instance (GObject o, IsDescendantOf ProgressBar o) => ProgressBarK o+data ProgressBarEllipsizePropertyInfo+data ProgressBarFractionPropertyInfo+data ProgressBarInvertedPropertyInfo+data ProgressBarPulseStepPropertyInfo+data ProgressBarShowTextPropertyInfo+data ProgressBarTextPropertyInfo
+ GI/Gtk/Objects/ProgressBarAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.ProgressBarAccessible+    ( ++-- * Exported types+    ProgressBarAccessible(..)               ,+    ProgressBarAccessibleK                  ,+    toProgressBarAccessible                 ,+    noProgressBarAccessible                 ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype ProgressBarAccessible = ProgressBarAccessible (ForeignPtr ProgressBarAccessible)+foreign import ccall "gtk_progress_bar_accessible_get_type"+    c_gtk_progress_bar_accessible_get_type :: IO GType++type instance ParentTypes ProgressBarAccessible = ProgressBarAccessibleParentTypes+type ProgressBarAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Value]++instance GObject ProgressBarAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_progress_bar_accessible_get_type+    ++class GObject o => ProgressBarAccessibleK o+instance (GObject o, IsDescendantOf ProgressBarAccessible o) => ProgressBarAccessibleK o++toProgressBarAccessible :: ProgressBarAccessibleK o => o -> IO ProgressBarAccessible+toProgressBarAccessible = unsafeCastTo ProgressBarAccessible++noProgressBarAccessible :: Maybe ProgressBarAccessible+noProgressBarAccessible = Nothing++type instance AttributeList ProgressBarAccessible = ProgressBarAccessibleAttributeList+type ProgressBarAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ProgressBarAccessible = ProgressBarAccessibleSignalList+type ProgressBarAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("value-changed", Atk.ValueValueChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/ProgressBarAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.ProgressBarAccessible where++import Prelude ()+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 ProgressBarAccessible = ProgressBarAccessible (ForeignPtr ProgressBarAccessible)+instance GObject ProgressBarAccessible where+class GObject o => ProgressBarAccessibleK o+instance (GObject o, IsDescendantOf ProgressBarAccessible o) => ProgressBarAccessibleK o
+ GI/Gtk/Objects/RadioAction.hs view
@@ -0,0 +1,430 @@++{- |+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.Gtk.Objects.RadioAction+    ( ++-- * Exported types+    RadioAction(..)                         ,+    RadioActionK                            ,+    toRadioAction                           ,+    noRadioAction                           ,+++ -- * Methods+-- ** radioActionGetCurrentValue+    radioActionGetCurrentValue              ,+++-- ** radioActionGetGroup+    radioActionGetGroup                     ,+++-- ** radioActionJoinGroup+    radioActionJoinGroup                    ,+++-- ** radioActionNew+    radioActionNew                          ,+++-- ** radioActionSetCurrentValue+    radioActionSetCurrentValue              ,+++-- ** radioActionSetGroup+    radioActionSetGroup                     ,+++++ -- * Properties+-- ** CurrentValue+    RadioActionCurrentValuePropertyInfo     ,+    constructRadioActionCurrentValue        ,+    getRadioActionCurrentValue              ,+    setRadioActionCurrentValue              ,+++-- ** Group+    RadioActionGroupPropertyInfo            ,+    constructRadioActionGroup               ,+    setRadioActionGroup                     ,+++-- ** Value+    RadioActionValuePropertyInfo            ,+    constructRadioActionValue               ,+    getRadioActionValue                     ,+    setRadioActionValue                     ,+++++ -- * Signals+-- ** Changed+    RadioActionChangedCallback              ,+    RadioActionChangedCallbackC             ,+    RadioActionChangedSignalInfo            ,+    afterRadioActionChanged                 ,+    mkRadioActionChangedCallback            ,+    noRadioActionChangedCallback            ,+    onRadioActionChanged                    ,+    radioActionChangedCallbackWrapper       ,+    radioActionChangedClosure               ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype RadioAction = RadioAction (ForeignPtr RadioAction)+foreign import ccall "gtk_radio_action_get_type"+    c_gtk_radio_action_get_type :: IO GType++type instance ParentTypes RadioAction = RadioActionParentTypes+type RadioActionParentTypes = '[ToggleAction, Action, GObject.Object, Buildable]++instance GObject RadioAction where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_radio_action_get_type+    ++class GObject o => RadioActionK o+instance (GObject o, IsDescendantOf RadioAction o) => RadioActionK o++toRadioAction :: RadioActionK o => o -> IO RadioAction+toRadioAction = unsafeCastTo RadioAction++noRadioAction :: Maybe RadioAction+noRadioAction = Nothing++-- signal RadioAction::changed+type RadioActionChangedCallback =+    RadioAction ->+    IO ()++noRadioActionChangedCallback :: Maybe RadioActionChangedCallback+noRadioActionChangedCallback = Nothing++type RadioActionChangedCallbackC =+    Ptr () ->                               -- object+    Ptr RadioAction ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRadioActionChangedCallback :: RadioActionChangedCallbackC -> IO (FunPtr RadioActionChangedCallbackC)++radioActionChangedClosure :: RadioActionChangedCallback -> IO Closure+radioActionChangedClosure cb = newCClosure =<< mkRadioActionChangedCallback wrapped+    where wrapped = radioActionChangedCallbackWrapper cb++radioActionChangedCallbackWrapper ::+    RadioActionChangedCallback ->+    Ptr () ->+    Ptr RadioAction ->+    Ptr () ->+    IO ()+radioActionChangedCallbackWrapper _cb _ current _ = do+    current' <- (newObject RadioAction) current+    _cb  current'++onRadioActionChanged :: (GObject a, MonadIO m) => a -> RadioActionChangedCallback -> m SignalHandlerId+onRadioActionChanged obj cb = liftIO $ connectRadioActionChanged obj cb SignalConnectBefore+afterRadioActionChanged :: (GObject a, MonadIO m) => a -> RadioActionChangedCallback -> m SignalHandlerId+afterRadioActionChanged obj cb = connectRadioActionChanged obj cb SignalConnectAfter++connectRadioActionChanged :: (GObject a, MonadIO m) =>+                             a -> RadioActionChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectRadioActionChanged obj cb after = liftIO $ do+    cb' <- mkRadioActionChangedCallback (radioActionChangedCallbackWrapper cb)+    connectSignalFunPtr obj "changed" cb' after++-- VVV Prop "current-value"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getRadioActionCurrentValue :: (MonadIO m, RadioActionK o) => o -> m Int32+getRadioActionCurrentValue obj = liftIO $ getObjectPropertyCInt obj "current-value"++setRadioActionCurrentValue :: (MonadIO m, RadioActionK o) => o -> Int32 -> m ()+setRadioActionCurrentValue obj val = liftIO $ setObjectPropertyCInt obj "current-value" val++constructRadioActionCurrentValue :: Int32 -> IO ([Char], GValue)+constructRadioActionCurrentValue val = constructObjectPropertyCInt "current-value" val++data RadioActionCurrentValuePropertyInfo+instance AttrInfo RadioActionCurrentValuePropertyInfo where+    type AttrAllowedOps RadioActionCurrentValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RadioActionCurrentValuePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint RadioActionCurrentValuePropertyInfo = RadioActionK+    type AttrGetType RadioActionCurrentValuePropertyInfo = Int32+    type AttrLabel RadioActionCurrentValuePropertyInfo = "RadioAction::current-value"+    attrGet _ = getRadioActionCurrentValue+    attrSet _ = setRadioActionCurrentValue+    attrConstruct _ = constructRadioActionCurrentValue++-- VVV Prop "group"+   -- Type: TInterface "Gtk" "RadioAction"+   -- Flags: [PropertyWritable]++setRadioActionGroup :: (MonadIO m, RadioActionK o, RadioActionK a) => o -> a -> m ()+setRadioActionGroup obj val = liftIO $ setObjectPropertyObject obj "group" val++constructRadioActionGroup :: (RadioActionK a) => a -> IO ([Char], GValue)+constructRadioActionGroup val = constructObjectPropertyObject "group" val++data RadioActionGroupPropertyInfo+instance AttrInfo RadioActionGroupPropertyInfo where+    type AttrAllowedOps RadioActionGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint RadioActionGroupPropertyInfo = RadioActionK+    type AttrBaseTypeConstraint RadioActionGroupPropertyInfo = RadioActionK+    type AttrGetType RadioActionGroupPropertyInfo = ()+    type AttrLabel RadioActionGroupPropertyInfo = "RadioAction::group"+    attrGet _ = undefined+    attrSet _ = setRadioActionGroup+    attrConstruct _ = constructRadioActionGroup++-- VVV Prop "value"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getRadioActionValue :: (MonadIO m, RadioActionK o) => o -> m Int32+getRadioActionValue obj = liftIO $ getObjectPropertyCInt obj "value"++setRadioActionValue :: (MonadIO m, RadioActionK o) => o -> Int32 -> m ()+setRadioActionValue obj val = liftIO $ setObjectPropertyCInt obj "value" val++constructRadioActionValue :: Int32 -> IO ([Char], GValue)+constructRadioActionValue val = constructObjectPropertyCInt "value" val++data RadioActionValuePropertyInfo+instance AttrInfo RadioActionValuePropertyInfo where+    type AttrAllowedOps RadioActionValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RadioActionValuePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint RadioActionValuePropertyInfo = RadioActionK+    type AttrGetType RadioActionValuePropertyInfo = Int32+    type AttrLabel RadioActionValuePropertyInfo = "RadioAction::value"+    attrGet _ = getRadioActionValue+    attrSet _ = setRadioActionValue+    attrConstruct _ = constructRadioActionValue++type instance AttributeList RadioAction = RadioActionAttributeList+type RadioActionAttributeList = ('[ '("action-group", ActionActionGroupPropertyInfo), '("active", ToggleActionActivePropertyInfo), '("always-show-image", ActionAlwaysShowImagePropertyInfo), '("current-value", RadioActionCurrentValuePropertyInfo), '("draw-as-radio", ToggleActionDrawAsRadioPropertyInfo), '("gicon", ActionGiconPropertyInfo), '("group", RadioActionGroupPropertyInfo), '("hide-if-empty", ActionHideIfEmptyPropertyInfo), '("icon-name", ActionIconNamePropertyInfo), '("is-important", ActionIsImportantPropertyInfo), '("label", ActionLabelPropertyInfo), '("name", ActionNamePropertyInfo), '("sensitive", ActionSensitivePropertyInfo), '("short-label", ActionShortLabelPropertyInfo), '("stock-id", ActionStockIdPropertyInfo), '("tooltip", ActionTooltipPropertyInfo), '("value", RadioActionValuePropertyInfo), '("visible", ActionVisiblePropertyInfo), '("visible-horizontal", ActionVisibleHorizontalPropertyInfo), '("visible-overflown", ActionVisibleOverflownPropertyInfo), '("visible-vertical", ActionVisibleVerticalPropertyInfo)] :: [(Symbol, *)])++data RadioActionChangedSignalInfo+instance SignalInfo RadioActionChangedSignalInfo where+    type HaskellCallbackType RadioActionChangedSignalInfo = RadioActionChangedCallback+    connectSignal _ = connectRadioActionChanged++type instance SignalList RadioAction = RadioActionSignalList+type RadioActionSignalList = ('[ '("activate", ActionActivateSignalInfo), '("changed", RadioActionChangedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("toggled", ToggleActionToggledSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RadioAction::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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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 = "name", argType = TBasicType TUTF8, 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 = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, 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 : TInterface "Gtk" "RadioAction"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_action_new" gtk_radio_action_new :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- tooltip : TBasicType TUTF8+    CString ->                              -- stock_id : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt32+    IO (Ptr RadioAction)++{-# DEPRECATED radioActionNew ["(Since version 3.10)"]#-}+radioActionNew ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- tooltip+    Maybe (T.Text) ->                       -- stock_id+    Int32 ->                                -- value+    m RadioAction+radioActionNew name label tooltip stock_id value = liftIO $ do+    name' <- textToCString name+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    maybeStock_id <- case stock_id of+        Nothing -> return nullPtr+        Just jStock_id -> do+            jStock_id' <- textToCString jStock_id+            return jStock_id'+    result <- gtk_radio_action_new name' maybeLabel maybeTooltip maybeStock_id value+    checkUnexpectedReturnNULL "gtk_radio_action_new" result+    result' <- (wrapObject RadioAction) result+    freeMem name'+    freeMem maybeLabel+    freeMem maybeTooltip+    freeMem maybeStock_id+    return result'++-- method RadioAction::get_current_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_action_get_current_value" gtk_radio_action_get_current_value :: +    Ptr RadioAction ->                      -- _obj : TInterface "Gtk" "RadioAction"+    IO Int32++{-# DEPRECATED radioActionGetCurrentValue ["(Since version 3.10)"]#-}+radioActionGetCurrentValue ::+    (MonadIO m, RadioActionK a) =>+    a ->                                    -- _obj+    m Int32+radioActionGetCurrentValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_radio_action_get_current_value _obj'+    touchManagedPtr _obj+    return result++-- method RadioAction::get_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "RadioAction")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_action_get_group" gtk_radio_action_get_group :: +    Ptr RadioAction ->                      -- _obj : TInterface "Gtk" "RadioAction"+    IO (Ptr (GSList (Ptr RadioAction)))++{-# DEPRECATED radioActionGetGroup ["(Since version 3.10)"]#-}+radioActionGetGroup ::+    (MonadIO m, RadioActionK a) =>+    a ->                                    -- _obj+    m [RadioAction]+radioActionGetGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_radio_action_get_group _obj'+    checkUnexpectedReturnNULL "gtk_radio_action_get_group" result+    result' <- unpackGSList result+    result'' <- mapM (newObject RadioAction) result'+    touchManagedPtr _obj+    return result''++-- method RadioAction::join_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_action_join_group" gtk_radio_action_join_group :: +    Ptr RadioAction ->                      -- _obj : TInterface "Gtk" "RadioAction"+    Ptr RadioAction ->                      -- group_source : TInterface "Gtk" "RadioAction"+    IO ()++{-# DEPRECATED radioActionJoinGroup ["(Since version 3.10)"]#-}+radioActionJoinGroup ::+    (MonadIO m, RadioActionK a, RadioActionK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- group_source+    m ()+radioActionJoinGroup _obj group_source = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeGroup_source <- case group_source of+        Nothing -> return nullPtr+        Just jGroup_source -> do+            let jGroup_source' = unsafeManagedPtrCastPtr jGroup_source+            return jGroup_source'+    gtk_radio_action_join_group _obj' maybeGroup_source+    touchManagedPtr _obj+    whenJust group_source touchManagedPtr+    return ()++-- method RadioAction::set_current_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "current_value", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "current_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 "gtk_radio_action_set_current_value" gtk_radio_action_set_current_value :: +    Ptr RadioAction ->                      -- _obj : TInterface "Gtk" "RadioAction"+    Int32 ->                                -- current_value : TBasicType TInt32+    IO ()++{-# DEPRECATED radioActionSetCurrentValue ["(Since version 3.10)"]#-}+radioActionSetCurrentValue ::+    (MonadIO m, RadioActionK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- current_value+    m ()+radioActionSetCurrentValue _obj current_value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_radio_action_set_current_value _obj' current_value+    touchManagedPtr _obj+    return ()++-- method RadioAction::set_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioAction"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioAction"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_action_set_group" gtk_radio_action_set_group :: +    Ptr RadioAction ->                      -- _obj : TInterface "Gtk" "RadioAction"+    Ptr (GSList (Ptr RadioAction)) ->       -- group : TGSList (TInterface "Gtk" "RadioAction")+    IO ()++{-# DEPRECATED radioActionSetGroup ["(Since version 3.10)"]#-}+radioActionSetGroup ::+    (MonadIO m, RadioActionK a, RadioActionK b) =>+    a ->                                    -- _obj+    [b] ->                                  -- group+    m ()+radioActionSetGroup _obj group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    gtk_radio_action_set_group _obj' group''+    touchManagedPtr _obj+    mapM_ touchManagedPtr group+    g_slist_free group''+    return ()++
+ GI/Gtk/Objects/RadioAction.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gtk.Objects.RadioAction where++import Prelude ()+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 RadioAction = RadioAction (ForeignPtr RadioAction)+instance GObject RadioAction where+class GObject o => RadioActionK o+instance (GObject o, IsDescendantOf RadioAction o) => RadioActionK o+data RadioActionCurrentValuePropertyInfo+data RadioActionGroupPropertyInfo+data RadioActionValuePropertyInfo+data RadioActionChangedSignalInfo
+ GI/Gtk/Objects/RadioButton.hs view
@@ -0,0 +1,465 @@++{- |+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.Gtk.Objects.RadioButton+    ( ++-- * Exported types+    RadioButton(..)                         ,+    RadioButtonK                            ,+    toRadioButton                           ,+    noRadioButton                           ,+++ -- * Methods+-- ** radioButtonGetGroup+    radioButtonGetGroup                     ,+++-- ** radioButtonJoinGroup+    radioButtonJoinGroup                    ,+++-- ** radioButtonNew+    radioButtonNew                          ,+++-- ** radioButtonNewFromWidget+    radioButtonNewFromWidget                ,+++-- ** radioButtonNewWithLabel+    radioButtonNewWithLabel                 ,+++-- ** radioButtonNewWithLabelFromWidget+    radioButtonNewWithLabelFromWidget       ,+++-- ** radioButtonNewWithMnemonic+    radioButtonNewWithMnemonic              ,+++-- ** radioButtonNewWithMnemonicFromWidget+    radioButtonNewWithMnemonicFromWidget    ,+++-- ** radioButtonSetGroup+    radioButtonSetGroup                     ,+++++ -- * Properties+-- ** Group+    RadioButtonGroupPropertyInfo            ,+    constructRadioButtonGroup               ,+    setRadioButtonGroup                     ,+++++ -- * Signals+-- ** GroupChanged+    RadioButtonGroupChangedCallback         ,+    RadioButtonGroupChangedCallbackC        ,+    RadioButtonGroupChangedSignalInfo       ,+    afterRadioButtonGroupChanged            ,+    mkRadioButtonGroupChangedCallback       ,+    noRadioButtonGroupChangedCallback       ,+    onRadioButtonGroupChanged               ,+    radioButtonGroupChangedCallbackWrapper  ,+    radioButtonGroupChangedClosure          ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RadioButton = RadioButton (ForeignPtr RadioButton)+foreign import ccall "gtk_radio_button_get_type"+    c_gtk_radio_button_get_type :: IO GType++type instance ParentTypes RadioButton = RadioButtonParentTypes+type RadioButtonParentTypes = '[CheckButton, ToggleButton, Button, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject RadioButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_radio_button_get_type+    ++class GObject o => RadioButtonK o+instance (GObject o, IsDescendantOf RadioButton o) => RadioButtonK o++toRadioButton :: RadioButtonK o => o -> IO RadioButton+toRadioButton = unsafeCastTo RadioButton++noRadioButton :: Maybe RadioButton+noRadioButton = Nothing++-- signal RadioButton::group-changed+type RadioButtonGroupChangedCallback =+    IO ()++noRadioButtonGroupChangedCallback :: Maybe RadioButtonGroupChangedCallback+noRadioButtonGroupChangedCallback = Nothing++type RadioButtonGroupChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRadioButtonGroupChangedCallback :: RadioButtonGroupChangedCallbackC -> IO (FunPtr RadioButtonGroupChangedCallbackC)++radioButtonGroupChangedClosure :: RadioButtonGroupChangedCallback -> IO Closure+radioButtonGroupChangedClosure cb = newCClosure =<< mkRadioButtonGroupChangedCallback wrapped+    where wrapped = radioButtonGroupChangedCallbackWrapper cb++radioButtonGroupChangedCallbackWrapper ::+    RadioButtonGroupChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+radioButtonGroupChangedCallbackWrapper _cb _ _ = do+    _cb ++onRadioButtonGroupChanged :: (GObject a, MonadIO m) => a -> RadioButtonGroupChangedCallback -> m SignalHandlerId+onRadioButtonGroupChanged obj cb = liftIO $ connectRadioButtonGroupChanged obj cb SignalConnectBefore+afterRadioButtonGroupChanged :: (GObject a, MonadIO m) => a -> RadioButtonGroupChangedCallback -> m SignalHandlerId+afterRadioButtonGroupChanged obj cb = connectRadioButtonGroupChanged obj cb SignalConnectAfter++connectRadioButtonGroupChanged :: (GObject a, MonadIO m) =>+                                  a -> RadioButtonGroupChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectRadioButtonGroupChanged obj cb after = liftIO $ do+    cb' <- mkRadioButtonGroupChangedCallback (radioButtonGroupChangedCallbackWrapper cb)+    connectSignalFunPtr obj "group-changed" cb' after++-- VVV Prop "group"+   -- Type: TInterface "Gtk" "RadioButton"+   -- Flags: [PropertyWritable]++setRadioButtonGroup :: (MonadIO m, RadioButtonK o, RadioButtonK a) => o -> a -> m ()+setRadioButtonGroup obj val = liftIO $ setObjectPropertyObject obj "group" val++constructRadioButtonGroup :: (RadioButtonK a) => a -> IO ([Char], GValue)+constructRadioButtonGroup val = constructObjectPropertyObject "group" val++data RadioButtonGroupPropertyInfo+instance AttrInfo RadioButtonGroupPropertyInfo where+    type AttrAllowedOps RadioButtonGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint RadioButtonGroupPropertyInfo = RadioButtonK+    type AttrBaseTypeConstraint RadioButtonGroupPropertyInfo = RadioButtonK+    type AttrGetType RadioButtonGroupPropertyInfo = ()+    type AttrLabel RadioButtonGroupPropertyInfo = "RadioButton::group"+    attrGet _ = undefined+    attrSet _ = setRadioButtonGroup+    attrConstruct _ = constructRadioButtonGroup++type instance AttributeList RadioButton = RadioButtonAttributeList+type RadioButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", ToggleButtonActivePropertyInfo), '("always-show-image", ButtonAlwaysShowImagePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-indicator", ToggleButtonDrawIndicatorPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focus-on-click", ButtonFocusOnClickPropertyInfo), '("group", RadioButtonGroupPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("image", ButtonImagePropertyInfo), '("image-position", ButtonImagePositionPropertyInfo), '("inconsistent", ToggleButtonInconsistentPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", ButtonLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("relief", ButtonReliefPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-stock", ButtonUseStockPropertyInfo), '("use-underline", ButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo), '("xalign", ButtonXalignPropertyInfo), '("yalign", ButtonYalignPropertyInfo)] :: [(Symbol, *)])++data RadioButtonGroupChangedSignalInfo+instance SignalInfo RadioButtonGroupChangedSignalInfo where+    type HaskellCallbackType RadioButtonGroupChangedSignalInfo = RadioButtonGroupChangedCallback+    connectSignal _ = connectRadioButtonGroupChanged++type instance SignalList RadioButton = RadioButtonSignalList+type RadioButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", ButtonActivateSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter", ButtonEnterSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("group-changed", RadioButtonGroupChangedSignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave", ButtonLeaveSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("pressed", ButtonPressedSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("released", ButtonReleasedSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggled", ToggleButtonToggledSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RadioButton::new+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new" gtk_radio_button_new :: +    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    IO (Ptr RadioButton)+++radioButtonNew ::+    (MonadIO m, RadioButtonK a) =>+    [a] ->                                  -- group+    m RadioButton+radioButtonNew group = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    result <- gtk_radio_button_new group''+    checkUnexpectedReturnNULL "gtk_radio_button_new" result+    result' <- (newObject RadioButton) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    return result'++-- method RadioButton::new_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new_from_widget" gtk_radio_button_new_from_widget :: +    Ptr RadioButton ->                      -- radio_group_member : TInterface "Gtk" "RadioButton"+    IO (Ptr RadioButton)+++radioButtonNewFromWidget ::+    (MonadIO m, RadioButtonK a) =>+    Maybe (a) ->                            -- radio_group_member+    m RadioButton+radioButtonNewFromWidget radio_group_member = liftIO $ do+    maybeRadio_group_member <- case radio_group_member of+        Nothing -> return nullPtr+        Just jRadio_group_member -> do+            let jRadio_group_member' = unsafeManagedPtrCastPtr jRadio_group_member+            return jRadio_group_member'+    result <- gtk_radio_button_new_from_widget maybeRadio_group_member+    checkUnexpectedReturnNULL "gtk_radio_button_new_from_widget" result+    result' <- (newObject RadioButton) result+    whenJust radio_group_member touchManagedPtr+    return result'++-- method RadioButton::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new_with_label" gtk_radio_button_new_with_label :: +    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioButton)+++radioButtonNewWithLabel ::+    (MonadIO m, RadioButtonK a) =>+    [a] ->                                  -- group+    T.Text ->                               -- label+    m RadioButton+radioButtonNewWithLabel group label = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    label' <- textToCString label+    result <- gtk_radio_button_new_with_label group'' label'+    checkUnexpectedReturnNULL "gtk_radio_button_new_with_label" result+    result' <- (newObject RadioButton) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    freeMem label'+    return result'++-- method RadioButton::new_with_label_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new_with_label_from_widget" gtk_radio_button_new_with_label_from_widget :: +    Ptr RadioButton ->                      -- radio_group_member : TInterface "Gtk" "RadioButton"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioButton)+++radioButtonNewWithLabelFromWidget ::+    (MonadIO m, RadioButtonK a) =>+    Maybe (a) ->                            -- radio_group_member+    T.Text ->                               -- label+    m RadioButton+radioButtonNewWithLabelFromWidget radio_group_member label = liftIO $ do+    maybeRadio_group_member <- case radio_group_member of+        Nothing -> return nullPtr+        Just jRadio_group_member -> do+            let jRadio_group_member' = unsafeManagedPtrCastPtr jRadio_group_member+            return jRadio_group_member'+    label' <- textToCString label+    result <- gtk_radio_button_new_with_label_from_widget maybeRadio_group_member label'+    checkUnexpectedReturnNULL "gtk_radio_button_new_with_label_from_widget" result+    result' <- (newObject RadioButton) result+    whenJust radio_group_member touchManagedPtr+    freeMem label'+    return result'++-- method RadioButton::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new_with_mnemonic" gtk_radio_button_new_with_mnemonic :: +    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioButton)+++radioButtonNewWithMnemonic ::+    (MonadIO m, RadioButtonK a) =>+    [a] ->                                  -- group+    T.Text ->                               -- label+    m RadioButton+radioButtonNewWithMnemonic group label = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    label' <- textToCString label+    result <- gtk_radio_button_new_with_mnemonic group'' label'+    checkUnexpectedReturnNULL "gtk_radio_button_new_with_mnemonic" result+    result' <- (newObject RadioButton) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    freeMem label'+    return result'++-- method RadioButton::new_with_mnemonic_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "radio_group_member", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_new_with_mnemonic_from_widget" gtk_radio_button_new_with_mnemonic_from_widget :: +    Ptr RadioButton ->                      -- radio_group_member : TInterface "Gtk" "RadioButton"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioButton)+++radioButtonNewWithMnemonicFromWidget ::+    (MonadIO m, RadioButtonK a) =>+    Maybe (a) ->                            -- radio_group_member+    T.Text ->                               -- label+    m RadioButton+radioButtonNewWithMnemonicFromWidget radio_group_member label = liftIO $ do+    maybeRadio_group_member <- case radio_group_member of+        Nothing -> return nullPtr+        Just jRadio_group_member -> do+            let jRadio_group_member' = unsafeManagedPtrCastPtr jRadio_group_member+            return jRadio_group_member'+    label' <- textToCString label+    result <- gtk_radio_button_new_with_mnemonic_from_widget maybeRadio_group_member label'+    checkUnexpectedReturnNULL "gtk_radio_button_new_with_mnemonic_from_widget" result+    result' <- (newObject RadioButton) result+    whenJust radio_group_member touchManagedPtr+    freeMem label'+    return result'++-- method RadioButton::get_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "RadioButton")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_get_group" gtk_radio_button_get_group :: +    Ptr RadioButton ->                      -- _obj : TInterface "Gtk" "RadioButton"+    IO (Ptr (GSList (Ptr RadioButton)))+++radioButtonGetGroup ::+    (MonadIO m, RadioButtonK a) =>+    a ->                                    -- _obj+    m [RadioButton]+radioButtonGetGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_radio_button_get_group _obj'+    checkUnexpectedReturnNULL "gtk_radio_button_get_group" result+    result' <- unpackGSList result+    result'' <- mapM (newObject RadioButton) result'+    touchManagedPtr _obj+    return result''++-- method RadioButton::join_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_join_group" gtk_radio_button_join_group :: +    Ptr RadioButton ->                      -- _obj : TInterface "Gtk" "RadioButton"+    Ptr RadioButton ->                      -- group_source : TInterface "Gtk" "RadioButton"+    IO ()+++radioButtonJoinGroup ::+    (MonadIO m, RadioButtonK a, RadioButtonK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- group_source+    m ()+radioButtonJoinGroup _obj group_source = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeGroup_source <- case group_source of+        Nothing -> return nullPtr+        Just jGroup_source -> do+            let jGroup_source' = unsafeManagedPtrCastPtr jGroup_source+            return jGroup_source'+    gtk_radio_button_join_group _obj' maybeGroup_source+    touchManagedPtr _obj+    whenJust group_source touchManagedPtr+    return ()++-- method RadioButton::set_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_button_set_group" gtk_radio_button_set_group :: +    Ptr RadioButton ->                      -- _obj : TInterface "Gtk" "RadioButton"+    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    IO ()+++radioButtonSetGroup ::+    (MonadIO m, RadioButtonK a, RadioButtonK b) =>+    a ->                                    -- _obj+    [b] ->                                  -- group+    m ()+radioButtonSetGroup _obj group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    gtk_radio_button_set_group _obj' group''+    touchManagedPtr _obj+    mapM_ touchManagedPtr group+    g_slist_free group''+    return ()++
+ GI/Gtk/Objects/RadioButton.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.RadioButton where++import Prelude ()+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 RadioButton = RadioButton (ForeignPtr RadioButton)+instance GObject RadioButton where+class GObject o => RadioButtonK o+instance (GObject o, IsDescendantOf RadioButton o) => RadioButtonK o+data RadioButtonGroupPropertyInfo+data RadioButtonGroupChangedSignalInfo
+ GI/Gtk/Objects/RadioButtonAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.RadioButtonAccessible+    ( ++-- * Exported types+    RadioButtonAccessible(..)               ,+    RadioButtonAccessibleK                  ,+    toRadioButtonAccessible                 ,+    noRadioButtonAccessible                 ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RadioButtonAccessible = RadioButtonAccessible (ForeignPtr RadioButtonAccessible)+foreign import ccall "gtk_radio_button_accessible_get_type"+    c_gtk_radio_button_accessible_get_type :: IO GType++type instance ParentTypes RadioButtonAccessible = RadioButtonAccessibleParentTypes+type RadioButtonAccessibleParentTypes = '[ToggleButtonAccessible, ButtonAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Image]++instance GObject RadioButtonAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_radio_button_accessible_get_type+    ++class GObject o => RadioButtonAccessibleK o+instance (GObject o, IsDescendantOf RadioButtonAccessible o) => RadioButtonAccessibleK o++toRadioButtonAccessible :: RadioButtonAccessibleK o => o -> IO RadioButtonAccessible+toRadioButtonAccessible = unsafeCastTo RadioButtonAccessible++noRadioButtonAccessible :: Maybe RadioButtonAccessible+noRadioButtonAccessible = Nothing++type instance AttributeList RadioButtonAccessible = RadioButtonAccessibleAttributeList+type RadioButtonAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList RadioButtonAccessible = RadioButtonAccessibleSignalList+type RadioButtonAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/RadioButtonAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.RadioButtonAccessible where++import Prelude ()+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 RadioButtonAccessible = RadioButtonAccessible (ForeignPtr RadioButtonAccessible)+instance GObject RadioButtonAccessible where+class GObject o => RadioButtonAccessibleK o+instance (GObject o, IsDescendantOf RadioButtonAccessible o) => RadioButtonAccessibleK o
+ GI/Gtk/Objects/RadioMenuItem.hs view
@@ -0,0 +1,473 @@++{- |+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.Gtk.Objects.RadioMenuItem+    ( ++-- * Exported types+    RadioMenuItem(..)                       ,+    RadioMenuItemK                          ,+    toRadioMenuItem                         ,+    noRadioMenuItem                         ,+++ -- * Methods+-- ** radioMenuItemGetGroup+    radioMenuItemGetGroup                   ,+++-- ** radioMenuItemJoinGroup+    radioMenuItemJoinGroup                  ,+++-- ** radioMenuItemNew+    radioMenuItemNew                        ,+++-- ** radioMenuItemNewFromWidget+    radioMenuItemNewFromWidget              ,+++-- ** radioMenuItemNewWithLabel+    radioMenuItemNewWithLabel               ,+++-- ** radioMenuItemNewWithLabelFromWidget+    radioMenuItemNewWithLabelFromWidget     ,+++-- ** radioMenuItemNewWithMnemonic+    radioMenuItemNewWithMnemonic            ,+++-- ** radioMenuItemNewWithMnemonicFromWidget+    radioMenuItemNewWithMnemonicFromWidget  ,+++-- ** radioMenuItemSetGroup+    radioMenuItemSetGroup                   ,+++++ -- * Properties+-- ** Group+    RadioMenuItemGroupPropertyInfo          ,+    constructRadioMenuItemGroup             ,+    setRadioMenuItemGroup                   ,+++++ -- * Signals+-- ** GroupChanged+    RadioMenuItemGroupChangedCallback       ,+    RadioMenuItemGroupChangedCallbackC      ,+    RadioMenuItemGroupChangedSignalInfo     ,+    afterRadioMenuItemGroupChanged          ,+    mkRadioMenuItemGroupChangedCallback     ,+    noRadioMenuItemGroupChangedCallback     ,+    onRadioMenuItemGroupChanged             ,+    radioMenuItemGroupChangedCallbackWrapper,+    radioMenuItemGroupChangedClosure        ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RadioMenuItem = RadioMenuItem (ForeignPtr RadioMenuItem)+foreign import ccall "gtk_radio_menu_item_get_type"+    c_gtk_radio_menu_item_get_type :: IO GType++type instance ParentTypes RadioMenuItem = RadioMenuItemParentTypes+type RadioMenuItemParentTypes = '[CheckMenuItem, MenuItem, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject RadioMenuItem where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_radio_menu_item_get_type+    ++class GObject o => RadioMenuItemK o+instance (GObject o, IsDescendantOf RadioMenuItem o) => RadioMenuItemK o++toRadioMenuItem :: RadioMenuItemK o => o -> IO RadioMenuItem+toRadioMenuItem = unsafeCastTo RadioMenuItem++noRadioMenuItem :: Maybe RadioMenuItem+noRadioMenuItem = Nothing++-- signal RadioMenuItem::group-changed+type RadioMenuItemGroupChangedCallback =+    IO ()++noRadioMenuItemGroupChangedCallback :: Maybe RadioMenuItemGroupChangedCallback+noRadioMenuItemGroupChangedCallback = Nothing++type RadioMenuItemGroupChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRadioMenuItemGroupChangedCallback :: RadioMenuItemGroupChangedCallbackC -> IO (FunPtr RadioMenuItemGroupChangedCallbackC)++radioMenuItemGroupChangedClosure :: RadioMenuItemGroupChangedCallback -> IO Closure+radioMenuItemGroupChangedClosure cb = newCClosure =<< mkRadioMenuItemGroupChangedCallback wrapped+    where wrapped = radioMenuItemGroupChangedCallbackWrapper cb++radioMenuItemGroupChangedCallbackWrapper ::+    RadioMenuItemGroupChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+radioMenuItemGroupChangedCallbackWrapper _cb _ _ = do+    _cb ++onRadioMenuItemGroupChanged :: (GObject a, MonadIO m) => a -> RadioMenuItemGroupChangedCallback -> m SignalHandlerId+onRadioMenuItemGroupChanged obj cb = liftIO $ connectRadioMenuItemGroupChanged obj cb SignalConnectBefore+afterRadioMenuItemGroupChanged :: (GObject a, MonadIO m) => a -> RadioMenuItemGroupChangedCallback -> m SignalHandlerId+afterRadioMenuItemGroupChanged obj cb = connectRadioMenuItemGroupChanged obj cb SignalConnectAfter++connectRadioMenuItemGroupChanged :: (GObject a, MonadIO m) =>+                                    a -> RadioMenuItemGroupChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectRadioMenuItemGroupChanged obj cb after = liftIO $ do+    cb' <- mkRadioMenuItemGroupChangedCallback (radioMenuItemGroupChangedCallbackWrapper cb)+    connectSignalFunPtr obj "group-changed" cb' after++-- VVV Prop "group"+   -- Type: TInterface "Gtk" "RadioMenuItem"+   -- Flags: [PropertyWritable]++setRadioMenuItemGroup :: (MonadIO m, RadioMenuItemK o, RadioMenuItemK a) => o -> a -> m ()+setRadioMenuItemGroup obj val = liftIO $ setObjectPropertyObject obj "group" val++constructRadioMenuItemGroup :: (RadioMenuItemK a) => a -> IO ([Char], GValue)+constructRadioMenuItemGroup val = constructObjectPropertyObject "group" val++data RadioMenuItemGroupPropertyInfo+instance AttrInfo RadioMenuItemGroupPropertyInfo where+    type AttrAllowedOps RadioMenuItemGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint RadioMenuItemGroupPropertyInfo = RadioMenuItemK+    type AttrBaseTypeConstraint RadioMenuItemGroupPropertyInfo = RadioMenuItemK+    type AttrGetType RadioMenuItemGroupPropertyInfo = ()+    type AttrLabel RadioMenuItemGroupPropertyInfo = "RadioMenuItem::group"+    attrGet _ = undefined+    attrSet _ = setRadioMenuItemGroup+    attrConstruct _ = constructRadioMenuItemGroup++type instance AttributeList RadioMenuItem = RadioMenuItemAttributeList+type RadioMenuItemAttributeList = ('[ '("accel-path", MenuItemAccelPathPropertyInfo), '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", CheckMenuItemActivePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("draw-as-radio", CheckMenuItemDrawAsRadioPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("group", RadioMenuItemGroupPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inconsistent", CheckMenuItemInconsistentPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("label", MenuItemLabelPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("right-justified", MenuItemRightJustifiedPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("submenu", MenuItemSubmenuPropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-underline", MenuItemUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data RadioMenuItemGroupChangedSignalInfo+instance SignalInfo RadioMenuItemGroupChangedSignalInfo where+    type HaskellCallbackType RadioMenuItemGroupChangedSignalInfo = RadioMenuItemGroupChangedCallback+    connectSignal _ = connectRadioMenuItemGroupChanged++type instance SignalList RadioMenuItem = RadioMenuItemSignalList+type RadioMenuItemSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("activate", MenuItemActivateSignalInfo), '("activate-item", MenuItemActivateItemSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("deselect", MenuItemDeselectSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("group-changed", RadioMenuItemGroupChangedSignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("select", MenuItemSelectSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggle-size-allocate", MenuItemToggleSizeAllocateSignalInfo), '("toggle-size-request", MenuItemToggleSizeRequestSignalInfo), '("toggled", CheckMenuItemToggledSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RadioMenuItem::new+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new" gtk_radio_menu_item_new :: +    Ptr (GSList (Ptr RadioMenuItem)) ->     -- group : TGSList (TInterface "Gtk" "RadioMenuItem")+    IO (Ptr RadioMenuItem)+++radioMenuItemNew ::+    (MonadIO m, RadioMenuItemK a) =>+    [a] ->                                  -- group+    m RadioMenuItem+radioMenuItemNew group = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    result <- gtk_radio_menu_item_new group''+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new" result+    result' <- (newObject RadioMenuItem) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    return result'++-- method RadioMenuItem::new_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new_from_widget" gtk_radio_menu_item_new_from_widget :: +    Ptr RadioMenuItem ->                    -- group : TInterface "Gtk" "RadioMenuItem"+    IO (Ptr RadioMenuItem)+++radioMenuItemNewFromWidget ::+    (MonadIO m, RadioMenuItemK a) =>+    Maybe (a) ->                            -- group+    m RadioMenuItem+radioMenuItemNewFromWidget group = liftIO $ do+    maybeGroup <- case group of+        Nothing -> return nullPtr+        Just jGroup -> do+            let jGroup' = unsafeManagedPtrCastPtr jGroup+            return jGroup'+    result <- gtk_radio_menu_item_new_from_widget maybeGroup+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new_from_widget" result+    result' <- (newObject RadioMenuItem) result+    whenJust group touchManagedPtr+    return result'++-- method RadioMenuItem::new_with_label+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new_with_label" gtk_radio_menu_item_new_with_label :: +    Ptr (GSList (Ptr RadioMenuItem)) ->     -- group : TGSList (TInterface "Gtk" "RadioMenuItem")+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioMenuItem)+++radioMenuItemNewWithLabel ::+    (MonadIO m, RadioMenuItemK a) =>+    [a] ->                                  -- group+    T.Text ->                               -- label+    m RadioMenuItem+radioMenuItemNewWithLabel group label = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    label' <- textToCString label+    result <- gtk_radio_menu_item_new_with_label group'' label'+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new_with_label" result+    result' <- (newObject RadioMenuItem) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    freeMem label'+    return result'++-- method RadioMenuItem::new_with_label_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, 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 = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, 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 : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new_with_label_from_widget" gtk_radio_menu_item_new_with_label_from_widget :: +    Ptr RadioMenuItem ->                    -- group : TInterface "Gtk" "RadioMenuItem"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioMenuItem)+++radioMenuItemNewWithLabelFromWidget ::+    (MonadIO m, RadioMenuItemK a) =>+    Maybe (a) ->                            -- group+    Maybe (T.Text) ->                       -- label+    m RadioMenuItem+radioMenuItemNewWithLabelFromWidget group label = liftIO $ do+    maybeGroup <- case group of+        Nothing -> return nullPtr+        Just jGroup -> do+            let jGroup' = unsafeManagedPtrCastPtr jGroup+            return jGroup'+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_radio_menu_item_new_with_label_from_widget maybeGroup maybeLabel+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new_with_label_from_widget" result+    result' <- (newObject RadioMenuItem) result+    whenJust group touchManagedPtr+    freeMem maybeLabel+    return result'++-- method RadioMenuItem::new_with_mnemonic+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, 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}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, 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}]+-- returnType : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new_with_mnemonic" gtk_radio_menu_item_new_with_mnemonic :: +    Ptr (GSList (Ptr RadioMenuItem)) ->     -- group : TGSList (TInterface "Gtk" "RadioMenuItem")+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioMenuItem)+++radioMenuItemNewWithMnemonic ::+    (MonadIO m, RadioMenuItemK a) =>+    [a] ->                                  -- group+    T.Text ->                               -- label+    m RadioMenuItem+radioMenuItemNewWithMnemonic group label = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    label' <- textToCString label+    result <- gtk_radio_menu_item_new_with_mnemonic group'' label'+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new_with_mnemonic" result+    result' <- (newObject RadioMenuItem) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    freeMem label'+    return result'++-- method RadioMenuItem::new_with_mnemonic_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, 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 = "group", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, 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 : TInterface "Gtk" "RadioMenuItem"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_new_with_mnemonic_from_widget" gtk_radio_menu_item_new_with_mnemonic_from_widget :: +    Ptr RadioMenuItem ->                    -- group : TInterface "Gtk" "RadioMenuItem"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr RadioMenuItem)+++radioMenuItemNewWithMnemonicFromWidget ::+    (MonadIO m, RadioMenuItemK a) =>+    Maybe (a) ->                            -- group+    Maybe (T.Text) ->                       -- label+    m RadioMenuItem+radioMenuItemNewWithMnemonicFromWidget group label = liftIO $ do+    maybeGroup <- case group of+        Nothing -> return nullPtr+        Just jGroup -> do+            let jGroup' = unsafeManagedPtrCastPtr jGroup+            return jGroup'+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    result <- gtk_radio_menu_item_new_with_mnemonic_from_widget maybeGroup maybeLabel+    checkUnexpectedReturnNULL "gtk_radio_menu_item_new_with_mnemonic_from_widget" result+    result' <- (newObject RadioMenuItem) result+    whenJust group touchManagedPtr+    freeMem maybeLabel+    return result'++-- method RadioMenuItem::get_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "RadioMenuItem")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_get_group" gtk_radio_menu_item_get_group :: +    Ptr RadioMenuItem ->                    -- _obj : TInterface "Gtk" "RadioMenuItem"+    IO (Ptr (GSList (Ptr RadioMenuItem)))+++radioMenuItemGetGroup ::+    (MonadIO m, RadioMenuItemK a) =>+    a ->                                    -- _obj+    m [RadioMenuItem]+radioMenuItemGetGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_radio_menu_item_get_group _obj'+    checkUnexpectedReturnNULL "gtk_radio_menu_item_get_group" result+    result' <- unpackGSList result+    result'' <- mapM (newObject RadioMenuItem) result'+    touchManagedPtr _obj+    return result''++-- method RadioMenuItem::join_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group_source", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_join_group" gtk_radio_menu_item_join_group :: +    Ptr RadioMenuItem ->                    -- _obj : TInterface "Gtk" "RadioMenuItem"+    Ptr RadioMenuItem ->                    -- group_source : TInterface "Gtk" "RadioMenuItem"+    IO ()+++radioMenuItemJoinGroup ::+    (MonadIO m, RadioMenuItemK a, RadioMenuItemK b) =>+    a ->                                    -- _obj+    Maybe (b) ->                            -- group_source+    m ()+radioMenuItemJoinGroup _obj group_source = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeGroup_source <- case group_source of+        Nothing -> return nullPtr+        Just jGroup_source -> do+            let jGroup_source' = unsafeManagedPtrCastPtr jGroup_source+            return jGroup_source'+    gtk_radio_menu_item_join_group _obj' maybeGroup_source+    touchManagedPtr _obj+    whenJust group_source touchManagedPtr+    return ()++-- method RadioMenuItem::set_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioMenuItem", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioMenuItem"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_menu_item_set_group" gtk_radio_menu_item_set_group :: +    Ptr RadioMenuItem ->                    -- _obj : TInterface "Gtk" "RadioMenuItem"+    Ptr (GSList (Ptr RadioMenuItem)) ->     -- group : TGSList (TInterface "Gtk" "RadioMenuItem")+    IO ()+++radioMenuItemSetGroup ::+    (MonadIO m, RadioMenuItemK a, RadioMenuItemK b) =>+    a ->                                    -- _obj+    [b] ->                                  -- group+    m ()+radioMenuItemSetGroup _obj group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    gtk_radio_menu_item_set_group _obj' group''+    touchManagedPtr _obj+    mapM_ touchManagedPtr group+    g_slist_free group''+    return ()++
+ GI/Gtk/Objects/RadioMenuItem.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gtk.Objects.RadioMenuItem where++import Prelude ()+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 RadioMenuItem = RadioMenuItem (ForeignPtr RadioMenuItem)+instance GObject RadioMenuItem where+class GObject o => RadioMenuItemK o+instance (GObject o, IsDescendantOf RadioMenuItem o) => RadioMenuItemK o+data RadioMenuItemGroupPropertyInfo+data RadioMenuItemGroupChangedSignalInfo
+ GI/Gtk/Objects/RadioMenuItemAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.RadioMenuItemAccessible+    ( ++-- * Exported types+    RadioMenuItemAccessible(..)             ,+    RadioMenuItemAccessibleK                ,+    toRadioMenuItemAccessible               ,+    noRadioMenuItemAccessible               ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RadioMenuItemAccessible = RadioMenuItemAccessible (ForeignPtr RadioMenuItemAccessible)+foreign import ccall "gtk_radio_menu_item_accessible_get_type"+    c_gtk_radio_menu_item_accessible_get_type :: IO GType++type instance ParentTypes RadioMenuItemAccessible = RadioMenuItemAccessibleParentTypes+type RadioMenuItemAccessibleParentTypes = '[CheckMenuItemAccessible, MenuItemAccessible, ContainerAccessible, WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Action, Atk.Component, Atk.Selection]++instance GObject RadioMenuItemAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_radio_menu_item_accessible_get_type+    ++class GObject o => RadioMenuItemAccessibleK o+instance (GObject o, IsDescendantOf RadioMenuItemAccessible o) => RadioMenuItemAccessibleK o++toRadioMenuItemAccessible :: RadioMenuItemAccessibleK o => o -> IO RadioMenuItemAccessible+toRadioMenuItemAccessible = unsafeCastTo RadioMenuItemAccessible++noRadioMenuItemAccessible :: Maybe RadioMenuItemAccessible+noRadioMenuItemAccessible = Nothing++type instance AttributeList RadioMenuItemAccessible = RadioMenuItemAccessibleAttributeList+type RadioMenuItemAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList RadioMenuItemAccessible = RadioMenuItemAccessibleSignalList+type RadioMenuItemAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("selection-changed", Atk.SelectionSelectionChangedSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/RadioMenuItemAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.RadioMenuItemAccessible where++import Prelude ()+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 RadioMenuItemAccessible = RadioMenuItemAccessible (ForeignPtr RadioMenuItemAccessible)+instance GObject RadioMenuItemAccessible where+class GObject o => RadioMenuItemAccessibleK o+instance (GObject o, IsDescendantOf RadioMenuItemAccessible o) => RadioMenuItemAccessibleK o
+ GI/Gtk/Objects/RadioToolButton.hs view
@@ -0,0 +1,297 @@++{- |+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.Gtk.Objects.RadioToolButton+    ( ++-- * Exported types+    RadioToolButton(..)                     ,+    RadioToolButtonK                        ,+    toRadioToolButton                       ,+    noRadioToolButton                       ,+++ -- * Methods+-- ** radioToolButtonGetGroup+    radioToolButtonGetGroup                 ,+++-- ** radioToolButtonNew+    radioToolButtonNew                      ,+++-- ** radioToolButtonNewFromStock+    radioToolButtonNewFromStock             ,+++-- ** radioToolButtonNewFromWidget+    radioToolButtonNewFromWidget            ,+++-- ** radioToolButtonNewWithStockFromWidget+    radioToolButtonNewWithStockFromWidget   ,+++-- ** radioToolButtonSetGroup+    radioToolButtonSetGroup                 ,+++++ -- * Properties+-- ** Group+    RadioToolButtonGroupPropertyInfo        ,+    constructRadioToolButtonGroup           ,+    setRadioToolButtonGroup                 ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RadioToolButton = RadioToolButton (ForeignPtr RadioToolButton)+foreign import ccall "gtk_radio_tool_button_get_type"+    c_gtk_radio_tool_button_get_type :: IO GType++type instance ParentTypes RadioToolButton = RadioToolButtonParentTypes+type RadioToolButtonParentTypes = '[ToggleToolButton, ToolButton, ToolItem, Bin, Container, Widget, GObject.Object, Atk.ImplementorIface, Actionable, Activatable, Buildable]++instance GObject RadioToolButton where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_radio_tool_button_get_type+    ++class GObject o => RadioToolButtonK o+instance (GObject o, IsDescendantOf RadioToolButton o) => RadioToolButtonK o++toRadioToolButton :: RadioToolButtonK o => o -> IO RadioToolButton+toRadioToolButton = unsafeCastTo RadioToolButton++noRadioToolButton :: Maybe RadioToolButton+noRadioToolButton = Nothing++-- VVV Prop "group"+   -- Type: TInterface "Gtk" "RadioToolButton"+   -- Flags: [PropertyWritable]++setRadioToolButtonGroup :: (MonadIO m, RadioToolButtonK o, RadioToolButtonK a) => o -> a -> m ()+setRadioToolButtonGroup obj val = liftIO $ setObjectPropertyObject obj "group" val++constructRadioToolButtonGroup :: (RadioToolButtonK a) => a -> IO ([Char], GValue)+constructRadioToolButtonGroup val = constructObjectPropertyObject "group" val++data RadioToolButtonGroupPropertyInfo+instance AttrInfo RadioToolButtonGroupPropertyInfo where+    type AttrAllowedOps RadioToolButtonGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct]+    type AttrSetTypeConstraint RadioToolButtonGroupPropertyInfo = RadioToolButtonK+    type AttrBaseTypeConstraint RadioToolButtonGroupPropertyInfo = RadioToolButtonK+    type AttrGetType RadioToolButtonGroupPropertyInfo = ()+    type AttrLabel RadioToolButtonGroupPropertyInfo = "RadioToolButton::group"+    attrGet _ = undefined+    attrSet _ = setRadioToolButtonGroup+    attrConstruct _ = constructRadioToolButtonGroup++type instance AttributeList RadioToolButton = RadioToolButtonAttributeList+type RadioToolButtonAttributeList = ('[ '("action-name", ActionableActionNamePropertyInfo), '("action-target", ActionableActionTargetPropertyInfo), '("active", ToggleToolButtonActivePropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("border-width", ContainerBorderWidthPropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("child", ContainerChildPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("group", RadioToolButtonGroupPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("icon-name", ToolButtonIconNamePropertyInfo), '("icon-widget", ToolButtonIconWidgetPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("is-important", ToolItemIsImportantPropertyInfo), '("label", ToolButtonLabelPropertyInfo), '("label-widget", ToolButtonLabelWidgetPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("related-action", ActivatableRelatedActionPropertyInfo), '("resize-mode", ContainerResizeModePropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("stock-id", ToolButtonStockIdPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("use-action-appearance", ActivatableUseActionAppearancePropertyInfo), '("use-underline", ToolButtonUseUnderlinePropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("visible-horizontal", ToolItemVisibleHorizontalPropertyInfo), '("visible-vertical", ToolItemVisibleVerticalPropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++type instance SignalList RadioToolButton = RadioToolButtonSignalList+type RadioToolButtonSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("add", ContainerAddSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("check-resize", ContainerCheckResizeSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("clicked", ToolButtonClickedSignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("create-menu-proxy", ToolItemCreateMenuProxySignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("remove", ContainerRemoveSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("set-focus-child", ContainerSetFocusChildSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("toggled", ToggleToolButtonToggledSignalInfo), '("toolbar-reconfigured", ToolItemToolbarReconfiguredSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RadioToolButton::new+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_new" gtk_radio_tool_button_new :: +    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    IO (Ptr RadioToolButton)+++radioToolButtonNew ::+    (MonadIO m, RadioButtonK a) =>+    [a] ->                                  -- group+    m RadioToolButton+radioToolButtonNew group = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    result <- gtk_radio_tool_button_new group''+    checkUnexpectedReturnNULL "gtk_radio_tool_button_new" result+    result' <- (newObject RadioToolButton) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    return result'++-- method RadioToolButton::new_from_stock+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_new_from_stock" gtk_radio_tool_button_new_from_stock :: +    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr RadioToolButton)++{-# DEPRECATED radioToolButtonNewFromStock ["(Since version 3.10)","Use gtk_radio_tool_button_new() instead."]#-}+radioToolButtonNewFromStock ::+    (MonadIO m, RadioButtonK a) =>+    [a] ->                                  -- group+    T.Text ->                               -- stock_id+    m RadioToolButton+radioToolButtonNewFromStock group stock_id = liftIO $ do+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    stock_id' <- textToCString stock_id+    result <- gtk_radio_tool_button_new_from_stock group'' stock_id'+    checkUnexpectedReturnNULL "gtk_radio_tool_button_new_from_stock" result+    result' <- (newObject RadioToolButton) result+    mapM_ touchManagedPtr group+    g_slist_free group''+    freeMem stock_id'+    return result'++-- method RadioToolButton::new_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_new_from_widget" gtk_radio_tool_button_new_from_widget :: +    Ptr RadioToolButton ->                  -- group : TInterface "Gtk" "RadioToolButton"+    IO (Ptr RadioToolButton)+++radioToolButtonNewFromWidget ::+    (MonadIO m, RadioToolButtonK a) =>+    Maybe (a) ->                            -- group+    m RadioToolButton+radioToolButtonNewFromWidget group = liftIO $ do+    maybeGroup <- case group of+        Nothing -> return nullPtr+        Just jGroup -> do+            let jGroup' = unsafeManagedPtrCastPtr jGroup+            return jGroup'+    result <- gtk_radio_tool_button_new_from_widget maybeGroup+    checkUnexpectedReturnNULL "gtk_radio_tool_button_new_from_widget" result+    result' <- (newObject RadioToolButton) result+    whenJust group touchManagedPtr+    return result'++-- method RadioToolButton::new_with_stock_from_widget+-- method type : Constructor+-- Args : [Arg {argName = "group", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "group", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RadioToolButton"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_new_with_stock_from_widget" gtk_radio_tool_button_new_with_stock_from_widget :: +    Ptr RadioToolButton ->                  -- group : TInterface "Gtk" "RadioToolButton"+    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr RadioToolButton)++{-# DEPRECATED radioToolButtonNewWithStockFromWidget ["(Since version 3.10)","gtk_radio_tool_button_new_from_widget"]#-}+radioToolButtonNewWithStockFromWidget ::+    (MonadIO m, RadioToolButtonK a) =>+    Maybe (a) ->                            -- group+    T.Text ->                               -- stock_id+    m RadioToolButton+radioToolButtonNewWithStockFromWidget group stock_id = liftIO $ do+    maybeGroup <- case group of+        Nothing -> return nullPtr+        Just jGroup -> do+            let jGroup' = unsafeManagedPtrCastPtr jGroup+            return jGroup'+    stock_id' <- textToCString stock_id+    result <- gtk_radio_tool_button_new_with_stock_from_widget maybeGroup stock_id'+    checkUnexpectedReturnNULL "gtk_radio_tool_button_new_with_stock_from_widget" result+    result' <- (newObject RadioToolButton) result+    whenJust group touchManagedPtr+    freeMem stock_id'+    return result'++-- method RadioToolButton::get_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGSList (TInterface "Gtk" "RadioButton")+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_get_group" gtk_radio_tool_button_get_group :: +    Ptr RadioToolButton ->                  -- _obj : TInterface "Gtk" "RadioToolButton"+    IO (Ptr (GSList (Ptr RadioButton)))+++radioToolButtonGetGroup ::+    (MonadIO m, RadioToolButtonK a) =>+    a ->                                    -- _obj+    m [RadioButton]+radioToolButtonGetGroup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_radio_tool_button_get_group _obj'+    checkUnexpectedReturnNULL "gtk_radio_tool_button_get_group" result+    result' <- unpackGSList result+    result'' <- mapM (newObject RadioButton) result'+    touchManagedPtr _obj+    return result''++-- method RadioToolButton::set_group+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RadioToolButton", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "group", argType = TGSList (TInterface "Gtk" "RadioButton"), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_radio_tool_button_set_group" gtk_radio_tool_button_set_group :: +    Ptr RadioToolButton ->                  -- _obj : TInterface "Gtk" "RadioToolButton"+    Ptr (GSList (Ptr RadioButton)) ->       -- group : TGSList (TInterface "Gtk" "RadioButton")+    IO ()+++radioToolButtonSetGroup ::+    (MonadIO m, RadioToolButtonK a, RadioButtonK b) =>+    a ->                                    -- _obj+    [b] ->                                  -- group+    m ()+radioToolButtonSetGroup _obj group = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let group' = map unsafeManagedPtrCastPtr group+    group'' <- packGSList group'+    gtk_radio_tool_button_set_group _obj' group''+    touchManagedPtr _obj+    mapM_ touchManagedPtr group+    g_slist_free group''+    return ()++
+ GI/Gtk/Objects/RadioToolButton.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.RadioToolButton where++import Prelude ()+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 RadioToolButton = RadioToolButton (ForeignPtr RadioToolButton)+instance GObject RadioToolButton where+class GObject o => RadioToolButtonK o+instance (GObject o, IsDescendantOf RadioToolButton o) => RadioToolButtonK o+data RadioToolButtonGroupPropertyInfo
+ GI/Gtk/Objects/Range.hs view
@@ -0,0 +1,1408 @@++{- |+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.Gtk.Objects.Range+    ( ++-- * Exported types+    Range(..)                               ,+    RangeK                                  ,+    toRange                                 ,+    noRange                                 ,+++ -- * Methods+-- ** rangeGetAdjustment+    rangeGetAdjustment                      ,+++-- ** rangeGetFillLevel+    rangeGetFillLevel                       ,+++-- ** rangeGetFlippable+    rangeGetFlippable                       ,+++-- ** rangeGetInverted+    rangeGetInverted                        ,+++-- ** rangeGetLowerStepperSensitivity+    rangeGetLowerStepperSensitivity         ,+++-- ** rangeGetMinSliderSize+    rangeGetMinSliderSize                   ,+++-- ** rangeGetRangeRect+    rangeGetRangeRect                       ,+++-- ** rangeGetRestrictToFillLevel+    rangeGetRestrictToFillLevel             ,+++-- ** rangeGetRoundDigits+    rangeGetRoundDigits                     ,+++-- ** rangeGetShowFillLevel+    rangeGetShowFillLevel                   ,+++-- ** rangeGetSliderRange+    rangeGetSliderRange                     ,+++-- ** rangeGetSliderSizeFixed+    rangeGetSliderSizeFixed                 ,+++-- ** rangeGetUpperStepperSensitivity+    rangeGetUpperStepperSensitivity         ,+++-- ** rangeGetValue+    rangeGetValue                           ,+++-- ** rangeSetAdjustment+    rangeSetAdjustment                      ,+++-- ** rangeSetFillLevel+    rangeSetFillLevel                       ,+++-- ** rangeSetFlippable+    rangeSetFlippable                       ,+++-- ** rangeSetIncrements+    rangeSetIncrements                      ,+++-- ** rangeSetInverted+    rangeSetInverted                        ,+++-- ** rangeSetLowerStepperSensitivity+    rangeSetLowerStepperSensitivity         ,+++-- ** rangeSetMinSliderSize+    rangeSetMinSliderSize                   ,+++-- ** rangeSetRange+    rangeSetRange                           ,+++-- ** rangeSetRestrictToFillLevel+    rangeSetRestrictToFillLevel             ,+++-- ** rangeSetRoundDigits+    rangeSetRoundDigits                     ,+++-- ** rangeSetShowFillLevel+    rangeSetShowFillLevel                   ,+++-- ** rangeSetSliderSizeFixed+    rangeSetSliderSizeFixed                 ,+++-- ** rangeSetUpperStepperSensitivity+    rangeSetUpperStepperSensitivity         ,+++-- ** rangeSetValue+    rangeSetValue                           ,+++++ -- * Properties+-- ** Adjustment+    RangeAdjustmentPropertyInfo             ,+    constructRangeAdjustment                ,+    getRangeAdjustment                      ,+    setRangeAdjustment                      ,+++-- ** FillLevel+    RangeFillLevelPropertyInfo              ,+    constructRangeFillLevel                 ,+    getRangeFillLevel                       ,+    setRangeFillLevel                       ,+++-- ** Inverted+    RangeInvertedPropertyInfo               ,+    constructRangeInverted                  ,+    getRangeInverted                        ,+    setRangeInverted                        ,+++-- ** LowerStepperSensitivity+    RangeLowerStepperSensitivityPropertyInfo,+    constructRangeLowerStepperSensitivity   ,+    getRangeLowerStepperSensitivity         ,+    setRangeLowerStepperSensitivity         ,+++-- ** RestrictToFillLevel+    RangeRestrictToFillLevelPropertyInfo    ,+    constructRangeRestrictToFillLevel       ,+    getRangeRestrictToFillLevel             ,+    setRangeRestrictToFillLevel             ,+++-- ** RoundDigits+    RangeRoundDigitsPropertyInfo            ,+    constructRangeRoundDigits               ,+    getRangeRoundDigits                     ,+    setRangeRoundDigits                     ,+++-- ** ShowFillLevel+    RangeShowFillLevelPropertyInfo          ,+    constructRangeShowFillLevel             ,+    getRangeShowFillLevel                   ,+    setRangeShowFillLevel                   ,+++-- ** UpperStepperSensitivity+    RangeUpperStepperSensitivityPropertyInfo,+    constructRangeUpperStepperSensitivity   ,+    getRangeUpperStepperSensitivity         ,+    setRangeUpperStepperSensitivity         ,+++++ -- * Signals+-- ** AdjustBounds+    RangeAdjustBoundsCallback               ,+    RangeAdjustBoundsCallbackC              ,+    RangeAdjustBoundsSignalInfo             ,+    afterRangeAdjustBounds                  ,+    mkRangeAdjustBoundsCallback             ,+    noRangeAdjustBoundsCallback             ,+    onRangeAdjustBounds                     ,+    rangeAdjustBoundsCallbackWrapper        ,+    rangeAdjustBoundsClosure                ,+++-- ** ChangeValue+    RangeChangeValueCallback                ,+    RangeChangeValueCallbackC               ,+    RangeChangeValueSignalInfo              ,+    afterRangeChangeValue                   ,+    mkRangeChangeValueCallback              ,+    noRangeChangeValueCallback              ,+    onRangeChangeValue                      ,+    rangeChangeValueCallbackWrapper         ,+    rangeChangeValueClosure                 ,+++-- ** MoveSlider+    RangeMoveSliderCallback                 ,+    RangeMoveSliderCallbackC                ,+    RangeMoveSliderSignalInfo               ,+    afterRangeMoveSlider                    ,+    mkRangeMoveSliderCallback               ,+    noRangeMoveSliderCallback               ,+    onRangeMoveSlider                       ,+    rangeMoveSliderCallbackWrapper          ,+    rangeMoveSliderClosure                  ,+++-- ** ValueChanged+    RangeValueChangedCallback               ,+    RangeValueChangedCallbackC              ,+    RangeValueChangedSignalInfo             ,+    afterRangeValueChanged                  ,+    mkRangeValueChangedCallback             ,+    noRangeValueChangedCallback             ,+    onRangeValueChanged                     ,+    rangeValueChangedCallbackWrapper        ,+    rangeValueChangedClosure                ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject+import qualified GI.Gdk as Gdk++newtype Range = Range (ForeignPtr Range)+foreign import ccall "gtk_range_get_type"+    c_gtk_range_get_type :: IO GType++type instance ParentTypes Range = RangeParentTypes+type RangeParentTypes = '[Widget, GObject.Object, Atk.ImplementorIface, Buildable, Orientable]++instance GObject Range where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gtk_range_get_type+    ++class GObject o => RangeK o+instance (GObject o, IsDescendantOf Range o) => RangeK o++toRange :: RangeK o => o -> IO Range+toRange = unsafeCastTo Range++noRange :: Maybe Range+noRange = Nothing++-- signal Range::adjust-bounds+type RangeAdjustBoundsCallback =+    Double ->+    IO ()++noRangeAdjustBoundsCallback :: Maybe RangeAdjustBoundsCallback+noRangeAdjustBoundsCallback = Nothing++type RangeAdjustBoundsCallbackC =+    Ptr () ->                               -- object+    CDouble ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRangeAdjustBoundsCallback :: RangeAdjustBoundsCallbackC -> IO (FunPtr RangeAdjustBoundsCallbackC)++rangeAdjustBoundsClosure :: RangeAdjustBoundsCallback -> IO Closure+rangeAdjustBoundsClosure cb = newCClosure =<< mkRangeAdjustBoundsCallback wrapped+    where wrapped = rangeAdjustBoundsCallbackWrapper cb++rangeAdjustBoundsCallbackWrapper ::+    RangeAdjustBoundsCallback ->+    Ptr () ->+    CDouble ->+    Ptr () ->+    IO ()+rangeAdjustBoundsCallbackWrapper _cb _ value _ = do+    let value' = realToFrac value+    _cb  value'++onRangeAdjustBounds :: (GObject a, MonadIO m) => a -> RangeAdjustBoundsCallback -> m SignalHandlerId+onRangeAdjustBounds obj cb = liftIO $ connectRangeAdjustBounds obj cb SignalConnectBefore+afterRangeAdjustBounds :: (GObject a, MonadIO m) => a -> RangeAdjustBoundsCallback -> m SignalHandlerId+afterRangeAdjustBounds obj cb = connectRangeAdjustBounds obj cb SignalConnectAfter++connectRangeAdjustBounds :: (GObject a, MonadIO m) =>+                            a -> RangeAdjustBoundsCallback -> SignalConnectMode -> m SignalHandlerId+connectRangeAdjustBounds obj cb after = liftIO $ do+    cb' <- mkRangeAdjustBoundsCallback (rangeAdjustBoundsCallbackWrapper cb)+    connectSignalFunPtr obj "adjust-bounds" cb' after++-- signal Range::change-value+type RangeChangeValueCallback =+    ScrollType ->+    Double ->+    IO Bool++noRangeChangeValueCallback :: Maybe RangeChangeValueCallback+noRangeChangeValueCallback = Nothing++type RangeChangeValueCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    CDouble ->+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkRangeChangeValueCallback :: RangeChangeValueCallbackC -> IO (FunPtr RangeChangeValueCallbackC)++rangeChangeValueClosure :: RangeChangeValueCallback -> IO Closure+rangeChangeValueClosure cb = newCClosure =<< mkRangeChangeValueCallback wrapped+    where wrapped = rangeChangeValueCallbackWrapper cb++rangeChangeValueCallbackWrapper ::+    RangeChangeValueCallback ->+    Ptr () ->+    CUInt ->+    CDouble ->+    Ptr () ->+    IO CInt+rangeChangeValueCallbackWrapper _cb _ scroll value _ = do+    let scroll' = (toEnum . fromIntegral) scroll+    let value' = realToFrac value+    result <- _cb  scroll' value'+    let result' = (fromIntegral . fromEnum) result+    return result'++onRangeChangeValue :: (GObject a, MonadIO m) => a -> RangeChangeValueCallback -> m SignalHandlerId+onRangeChangeValue obj cb = liftIO $ connectRangeChangeValue obj cb SignalConnectBefore+afterRangeChangeValue :: (GObject a, MonadIO m) => a -> RangeChangeValueCallback -> m SignalHandlerId+afterRangeChangeValue obj cb = connectRangeChangeValue obj cb SignalConnectAfter++connectRangeChangeValue :: (GObject a, MonadIO m) =>+                           a -> RangeChangeValueCallback -> SignalConnectMode -> m SignalHandlerId+connectRangeChangeValue obj cb after = liftIO $ do+    cb' <- mkRangeChangeValueCallback (rangeChangeValueCallbackWrapper cb)+    connectSignalFunPtr obj "change-value" cb' after++-- signal Range::move-slider+type RangeMoveSliderCallback =+    ScrollType ->+    IO ()++noRangeMoveSliderCallback :: Maybe RangeMoveSliderCallback+noRangeMoveSliderCallback = Nothing++type RangeMoveSliderCallbackC =+    Ptr () ->                               -- object+    CUInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRangeMoveSliderCallback :: RangeMoveSliderCallbackC -> IO (FunPtr RangeMoveSliderCallbackC)++rangeMoveSliderClosure :: RangeMoveSliderCallback -> IO Closure+rangeMoveSliderClosure cb = newCClosure =<< mkRangeMoveSliderCallback wrapped+    where wrapped = rangeMoveSliderCallbackWrapper cb++rangeMoveSliderCallbackWrapper ::+    RangeMoveSliderCallback ->+    Ptr () ->+    CUInt ->+    Ptr () ->+    IO ()+rangeMoveSliderCallbackWrapper _cb _ step _ = do+    let step' = (toEnum . fromIntegral) step+    _cb  step'++onRangeMoveSlider :: (GObject a, MonadIO m) => a -> RangeMoveSliderCallback -> m SignalHandlerId+onRangeMoveSlider obj cb = liftIO $ connectRangeMoveSlider obj cb SignalConnectBefore+afterRangeMoveSlider :: (GObject a, MonadIO m) => a -> RangeMoveSliderCallback -> m SignalHandlerId+afterRangeMoveSlider obj cb = connectRangeMoveSlider obj cb SignalConnectAfter++connectRangeMoveSlider :: (GObject a, MonadIO m) =>+                          a -> RangeMoveSliderCallback -> SignalConnectMode -> m SignalHandlerId+connectRangeMoveSlider obj cb after = liftIO $ do+    cb' <- mkRangeMoveSliderCallback (rangeMoveSliderCallbackWrapper cb)+    connectSignalFunPtr obj "move-slider" cb' after++-- signal Range::value-changed+type RangeValueChangedCallback =+    IO ()++noRangeValueChangedCallback :: Maybe RangeValueChangedCallback+noRangeValueChangedCallback = Nothing++type RangeValueChangedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRangeValueChangedCallback :: RangeValueChangedCallbackC -> IO (FunPtr RangeValueChangedCallbackC)++rangeValueChangedClosure :: RangeValueChangedCallback -> IO Closure+rangeValueChangedClosure cb = newCClosure =<< mkRangeValueChangedCallback wrapped+    where wrapped = rangeValueChangedCallbackWrapper cb++rangeValueChangedCallbackWrapper ::+    RangeValueChangedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+rangeValueChangedCallbackWrapper _cb _ _ = do+    _cb ++onRangeValueChanged :: (GObject a, MonadIO m) => a -> RangeValueChangedCallback -> m SignalHandlerId+onRangeValueChanged obj cb = liftIO $ connectRangeValueChanged obj cb SignalConnectBefore+afterRangeValueChanged :: (GObject a, MonadIO m) => a -> RangeValueChangedCallback -> m SignalHandlerId+afterRangeValueChanged obj cb = connectRangeValueChanged obj cb SignalConnectAfter++connectRangeValueChanged :: (GObject a, MonadIO m) =>+                            a -> RangeValueChangedCallback -> SignalConnectMode -> m SignalHandlerId+connectRangeValueChanged obj cb after = liftIO $ do+    cb' <- mkRangeValueChangedCallback (rangeValueChangedCallbackWrapper cb)+    connectSignalFunPtr obj "value-changed" cb' after++-- VVV Prop "adjustment"+   -- Type: TInterface "Gtk" "Adjustment"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getRangeAdjustment :: (MonadIO m, RangeK o) => o -> m Adjustment+getRangeAdjustment obj = liftIO $ getObjectPropertyObject obj "adjustment" Adjustment++setRangeAdjustment :: (MonadIO m, RangeK o, AdjustmentK a) => o -> a -> m ()+setRangeAdjustment obj val = liftIO $ setObjectPropertyObject obj "adjustment" val++constructRangeAdjustment :: (AdjustmentK a) => a -> IO ([Char], GValue)+constructRangeAdjustment val = constructObjectPropertyObject "adjustment" val++data RangeAdjustmentPropertyInfo+instance AttrInfo RangeAdjustmentPropertyInfo where+    type AttrAllowedOps RangeAdjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeAdjustmentPropertyInfo = AdjustmentK+    type AttrBaseTypeConstraint RangeAdjustmentPropertyInfo = RangeK+    type AttrGetType RangeAdjustmentPropertyInfo = Adjustment+    type AttrLabel RangeAdjustmentPropertyInfo = "Range::adjustment"+    attrGet _ = getRangeAdjustment+    attrSet _ = setRangeAdjustment+    attrConstruct _ = constructRangeAdjustment++-- VVV Prop "fill-level"+   -- Type: TBasicType TDouble+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeFillLevel :: (MonadIO m, RangeK o) => o -> m Double+getRangeFillLevel obj = liftIO $ getObjectPropertyDouble obj "fill-level"++setRangeFillLevel :: (MonadIO m, RangeK o) => o -> Double -> m ()+setRangeFillLevel obj val = liftIO $ setObjectPropertyDouble obj "fill-level" val++constructRangeFillLevel :: Double -> IO ([Char], GValue)+constructRangeFillLevel val = constructObjectPropertyDouble "fill-level" val++data RangeFillLevelPropertyInfo+instance AttrInfo RangeFillLevelPropertyInfo where+    type AttrAllowedOps RangeFillLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeFillLevelPropertyInfo = (~) Double+    type AttrBaseTypeConstraint RangeFillLevelPropertyInfo = RangeK+    type AttrGetType RangeFillLevelPropertyInfo = Double+    type AttrLabel RangeFillLevelPropertyInfo = "Range::fill-level"+    attrGet _ = getRangeFillLevel+    attrSet _ = setRangeFillLevel+    attrConstruct _ = constructRangeFillLevel++-- VVV Prop "inverted"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeInverted :: (MonadIO m, RangeK o) => o -> m Bool+getRangeInverted obj = liftIO $ getObjectPropertyBool obj "inverted"++setRangeInverted :: (MonadIO m, RangeK o) => o -> Bool -> m ()+setRangeInverted obj val = liftIO $ setObjectPropertyBool obj "inverted" val++constructRangeInverted :: Bool -> IO ([Char], GValue)+constructRangeInverted val = constructObjectPropertyBool "inverted" val++data RangeInvertedPropertyInfo+instance AttrInfo RangeInvertedPropertyInfo where+    type AttrAllowedOps RangeInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeInvertedPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RangeInvertedPropertyInfo = RangeK+    type AttrGetType RangeInvertedPropertyInfo = Bool+    type AttrLabel RangeInvertedPropertyInfo = "Range::inverted"+    attrGet _ = getRangeInverted+    attrSet _ = setRangeInverted+    attrConstruct _ = constructRangeInverted++-- VVV Prop "lower-stepper-sensitivity"+   -- Type: TInterface "Gtk" "SensitivityType"+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeLowerStepperSensitivity :: (MonadIO m, RangeK o) => o -> m SensitivityType+getRangeLowerStepperSensitivity obj = liftIO $ getObjectPropertyEnum obj "lower-stepper-sensitivity"++setRangeLowerStepperSensitivity :: (MonadIO m, RangeK o) => o -> SensitivityType -> m ()+setRangeLowerStepperSensitivity obj val = liftIO $ setObjectPropertyEnum obj "lower-stepper-sensitivity" val++constructRangeLowerStepperSensitivity :: SensitivityType -> IO ([Char], GValue)+constructRangeLowerStepperSensitivity val = constructObjectPropertyEnum "lower-stepper-sensitivity" val++data RangeLowerStepperSensitivityPropertyInfo+instance AttrInfo RangeLowerStepperSensitivityPropertyInfo where+    type AttrAllowedOps RangeLowerStepperSensitivityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeLowerStepperSensitivityPropertyInfo = (~) SensitivityType+    type AttrBaseTypeConstraint RangeLowerStepperSensitivityPropertyInfo = RangeK+    type AttrGetType RangeLowerStepperSensitivityPropertyInfo = SensitivityType+    type AttrLabel RangeLowerStepperSensitivityPropertyInfo = "Range::lower-stepper-sensitivity"+    attrGet _ = getRangeLowerStepperSensitivity+    attrSet _ = setRangeLowerStepperSensitivity+    attrConstruct _ = constructRangeLowerStepperSensitivity++-- VVV Prop "restrict-to-fill-level"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeRestrictToFillLevel :: (MonadIO m, RangeK o) => o -> m Bool+getRangeRestrictToFillLevel obj = liftIO $ getObjectPropertyBool obj "restrict-to-fill-level"++setRangeRestrictToFillLevel :: (MonadIO m, RangeK o) => o -> Bool -> m ()+setRangeRestrictToFillLevel obj val = liftIO $ setObjectPropertyBool obj "restrict-to-fill-level" val++constructRangeRestrictToFillLevel :: Bool -> IO ([Char], GValue)+constructRangeRestrictToFillLevel val = constructObjectPropertyBool "restrict-to-fill-level" val++data RangeRestrictToFillLevelPropertyInfo+instance AttrInfo RangeRestrictToFillLevelPropertyInfo where+    type AttrAllowedOps RangeRestrictToFillLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeRestrictToFillLevelPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RangeRestrictToFillLevelPropertyInfo = RangeK+    type AttrGetType RangeRestrictToFillLevelPropertyInfo = Bool+    type AttrLabel RangeRestrictToFillLevelPropertyInfo = "Range::restrict-to-fill-level"+    attrGet _ = getRangeRestrictToFillLevel+    attrSet _ = setRangeRestrictToFillLevel+    attrConstruct _ = constructRangeRestrictToFillLevel++-- VVV Prop "round-digits"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeRoundDigits :: (MonadIO m, RangeK o) => o -> m Int32+getRangeRoundDigits obj = liftIO $ getObjectPropertyCInt obj "round-digits"++setRangeRoundDigits :: (MonadIO m, RangeK o) => o -> Int32 -> m ()+setRangeRoundDigits obj val = liftIO $ setObjectPropertyCInt obj "round-digits" val++constructRangeRoundDigits :: Int32 -> IO ([Char], GValue)+constructRangeRoundDigits val = constructObjectPropertyCInt "round-digits" val++data RangeRoundDigitsPropertyInfo+instance AttrInfo RangeRoundDigitsPropertyInfo where+    type AttrAllowedOps RangeRoundDigitsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeRoundDigitsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint RangeRoundDigitsPropertyInfo = RangeK+    type AttrGetType RangeRoundDigitsPropertyInfo = Int32+    type AttrLabel RangeRoundDigitsPropertyInfo = "Range::round-digits"+    attrGet _ = getRangeRoundDigits+    attrSet _ = setRangeRoundDigits+    attrConstruct _ = constructRangeRoundDigits++-- VVV Prop "show-fill-level"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeShowFillLevel :: (MonadIO m, RangeK o) => o -> m Bool+getRangeShowFillLevel obj = liftIO $ getObjectPropertyBool obj "show-fill-level"++setRangeShowFillLevel :: (MonadIO m, RangeK o) => o -> Bool -> m ()+setRangeShowFillLevel obj val = liftIO $ setObjectPropertyBool obj "show-fill-level" val++constructRangeShowFillLevel :: Bool -> IO ([Char], GValue)+constructRangeShowFillLevel val = constructObjectPropertyBool "show-fill-level" val++data RangeShowFillLevelPropertyInfo+instance AttrInfo RangeShowFillLevelPropertyInfo where+    type AttrAllowedOps RangeShowFillLevelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeShowFillLevelPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RangeShowFillLevelPropertyInfo = RangeK+    type AttrGetType RangeShowFillLevelPropertyInfo = Bool+    type AttrLabel RangeShowFillLevelPropertyInfo = "Range::show-fill-level"+    attrGet _ = getRangeShowFillLevel+    attrSet _ = setRangeShowFillLevel+    attrConstruct _ = constructRangeShowFillLevel++-- VVV Prop "upper-stepper-sensitivity"+   -- Type: TInterface "Gtk" "SensitivityType"+   -- Flags: [PropertyReadable,PropertyWritable]++getRangeUpperStepperSensitivity :: (MonadIO m, RangeK o) => o -> m SensitivityType+getRangeUpperStepperSensitivity obj = liftIO $ getObjectPropertyEnum obj "upper-stepper-sensitivity"++setRangeUpperStepperSensitivity :: (MonadIO m, RangeK o) => o -> SensitivityType -> m ()+setRangeUpperStepperSensitivity obj val = liftIO $ setObjectPropertyEnum obj "upper-stepper-sensitivity" val++constructRangeUpperStepperSensitivity :: SensitivityType -> IO ([Char], GValue)+constructRangeUpperStepperSensitivity val = constructObjectPropertyEnum "upper-stepper-sensitivity" val++data RangeUpperStepperSensitivityPropertyInfo+instance AttrInfo RangeUpperStepperSensitivityPropertyInfo where+    type AttrAllowedOps RangeUpperStepperSensitivityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RangeUpperStepperSensitivityPropertyInfo = (~) SensitivityType+    type AttrBaseTypeConstraint RangeUpperStepperSensitivityPropertyInfo = RangeK+    type AttrGetType RangeUpperStepperSensitivityPropertyInfo = SensitivityType+    type AttrLabel RangeUpperStepperSensitivityPropertyInfo = "Range::upper-stepper-sensitivity"+    attrGet _ = getRangeUpperStepperSensitivity+    attrSet _ = setRangeUpperStepperSensitivity+    attrConstruct _ = constructRangeUpperStepperSensitivity++type instance AttributeList Range = RangeAttributeList+type RangeAttributeList = ('[ '("adjustment", RangeAdjustmentPropertyInfo), '("app-paintable", WidgetAppPaintablePropertyInfo), '("can-default", WidgetCanDefaultPropertyInfo), '("can-focus", WidgetCanFocusPropertyInfo), '("composite-child", WidgetCompositeChildPropertyInfo), '("double-buffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("fill-level", RangeFillLevelPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("has-default", WidgetHasDefaultPropertyInfo), '("has-focus", WidgetHasFocusPropertyInfo), '("has-tooltip", WidgetHasTooltipPropertyInfo), '("height-request", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpand-set", WidgetHexpandSetPropertyInfo), '("inverted", RangeInvertedPropertyInfo), '("is-focus", WidgetIsFocusPropertyInfo), '("lower-stepper-sensitivity", RangeLowerStepperSensitivityPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("margin-bottom", WidgetMarginBottomPropertyInfo), '("margin-end", WidgetMarginEndPropertyInfo), '("margin-left", WidgetMarginLeftPropertyInfo), '("margin-right", WidgetMarginRightPropertyInfo), '("margin-start", WidgetMarginStartPropertyInfo), '("margin-top", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("no-show-all", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("orientation", OrientableOrientationPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receives-default", WidgetReceivesDefaultPropertyInfo), '("restrict-to-fill-level", RangeRestrictToFillLevelPropertyInfo), '("round-digits", RangeRoundDigitsPropertyInfo), '("scale-factor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("show-fill-level", RangeShowFillLevelPropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltip-markup", WidgetTooltipMarkupPropertyInfo), '("tooltip-text", WidgetTooltipTextPropertyInfo), '("upper-stepper-sensitivity", RangeUpperStepperSensitivityPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpand-set", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("width-request", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])++data RangeAdjustBoundsSignalInfo+instance SignalInfo RangeAdjustBoundsSignalInfo where+    type HaskellCallbackType RangeAdjustBoundsSignalInfo = RangeAdjustBoundsCallback+    connectSignal _ = connectRangeAdjustBounds++data RangeChangeValueSignalInfo+instance SignalInfo RangeChangeValueSignalInfo where+    type HaskellCallbackType RangeChangeValueSignalInfo = RangeChangeValueCallback+    connectSignal _ = connectRangeChangeValue++data RangeMoveSliderSignalInfo+instance SignalInfo RangeMoveSliderSignalInfo where+    type HaskellCallbackType RangeMoveSliderSignalInfo = RangeMoveSliderCallback+    connectSignal _ = connectRangeMoveSlider++data RangeValueChangedSignalInfo+instance SignalInfo RangeValueChangedSignalInfo where+    type HaskellCallbackType RangeValueChangedSignalInfo = RangeValueChangedCallback+    connectSignal _ = connectRangeValueChanged++type instance SignalList Range = RangeSignalList+type RangeSignalList = ('[ '("accel-closures-changed", WidgetAccelClosuresChangedSignalInfo), '("adjust-bounds", RangeAdjustBoundsSignalInfo), '("button-press-event", WidgetButtonPressEventSignalInfo), '("button-release-event", WidgetButtonReleaseEventSignalInfo), '("can-activate-accel", WidgetCanActivateAccelSignalInfo), '("change-value", RangeChangeValueSignalInfo), '("child-notify", WidgetChildNotifySignalInfo), '("composited-changed", WidgetCompositedChangedSignalInfo), '("configure-event", WidgetConfigureEventSignalInfo), '("damage-event", WidgetDamageEventSignalInfo), '("delete-event", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroy-event", WidgetDestroyEventSignalInfo), '("direction-changed", WidgetDirectionChangedSignalInfo), '("drag-begin", WidgetDragBeginSignalInfo), '("drag-data-delete", WidgetDragDataDeleteSignalInfo), '("drag-data-get", WidgetDragDataGetSignalInfo), '("drag-data-received", WidgetDragDataReceivedSignalInfo), '("drag-drop", WidgetDragDropSignalInfo), '("drag-end", WidgetDragEndSignalInfo), '("drag-failed", WidgetDragFailedSignalInfo), '("drag-leave", WidgetDragLeaveSignalInfo), '("drag-motion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enter-notify-event", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("event-after", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focus-in-event", WidgetFocusInEventSignalInfo), '("focus-out-event", WidgetFocusOutEventSignalInfo), '("grab-broken-event", WidgetGrabBrokenEventSignalInfo), '("grab-focus", WidgetGrabFocusSignalInfo), '("grab-notify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchy-changed", WidgetHierarchyChangedSignalInfo), '("key-press-event", WidgetKeyPressEventSignalInfo), '("key-release-event", WidgetKeyReleaseEventSignalInfo), '("keynav-failed", WidgetKeynavFailedSignalInfo), '("leave-notify-event", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("map-event", WidgetMapEventSignalInfo), '("mnemonic-activate", WidgetMnemonicActivateSignalInfo), '("motion-notify-event", WidgetMotionNotifyEventSignalInfo), '("move-focus", WidgetMoveFocusSignalInfo), '("move-slider", RangeMoveSliderSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("parent-set", WidgetParentSetSignalInfo), '("popup-menu", WidgetPopupMenuSignalInfo), '("property-notify-event", WidgetPropertyNotifyEventSignalInfo), '("proximity-in-event", WidgetProximityInEventSignalInfo), '("proximity-out-event", WidgetProximityOutEventSignalInfo), '("query-tooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screen-changed", WidgetScreenChangedSignalInfo), '("scroll-event", WidgetScrollEventSignalInfo), '("selection-clear-event", WidgetSelectionClearEventSignalInfo), '("selection-get", WidgetSelectionGetSignalInfo), '("selection-notify-event", WidgetSelectionNotifyEventSignalInfo), '("selection-received", WidgetSelectionReceivedSignalInfo), '("selection-request-event", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("show-help", WidgetShowHelpSignalInfo), '("size-allocate", WidgetSizeAllocateSignalInfo), '("state-changed", WidgetStateChangedSignalInfo), '("state-flags-changed", WidgetStateFlagsChangedSignalInfo), '("style-set", WidgetStyleSetSignalInfo), '("style-updated", WidgetStyleUpdatedSignalInfo), '("touch-event", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmap-event", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("value-changed", RangeValueChangedSignalInfo), '("visibility-notify-event", WidgetVisibilityNotifyEventSignalInfo), '("window-state-event", WidgetWindowStateEventSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Range::get_adjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "Adjustment"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_adjustment" gtk_range_get_adjustment :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO (Ptr Adjustment)+++rangeGetAdjustment ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Adjustment+rangeGetAdjustment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_adjustment _obj'+    checkUnexpectedReturnNULL "gtk_range_get_adjustment" result+    result' <- (newObject Adjustment) result+    touchManagedPtr _obj+    return result'++-- method Range::get_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_fill_level" gtk_range_get_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CDouble+++rangeGetFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Double+rangeGetFillLevel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_fill_level _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Range::get_flippable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_flippable" gtk_range_get_flippable :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CInt+++rangeGetFlippable ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Bool+rangeGetFlippable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_flippable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Range::get_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_inverted" gtk_range_get_inverted :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CInt+++rangeGetInverted ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Bool+rangeGetInverted _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_inverted _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Range::get_lower_stepper_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SensitivityType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_lower_stepper_sensitivity" gtk_range_get_lower_stepper_sensitivity :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CUInt+++rangeGetLowerStepperSensitivity ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m SensitivityType+rangeGetLowerStepperSensitivity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_lower_stepper_sensitivity _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Range::get_min_slider_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_min_slider_size" gtk_range_get_min_slider_size :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO Int32+++rangeGetMinSliderSize ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Int32+rangeGetMinSliderSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_min_slider_size _obj'+    touchManagedPtr _obj+    return result++-- method Range::get_range_rect+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "range_rect", argType = TInterface "Gdk" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_range_rect" gtk_range_get_range_rect :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    Ptr Gdk.Rectangle ->                    -- range_rect : TInterface "Gdk" "Rectangle"+    IO ()+++rangeGetRangeRect ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m (Gdk.Rectangle)+rangeGetRangeRect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    range_rect <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle)+    gtk_range_get_range_rect _obj' range_rect+    range_rect' <- (wrapBoxed Gdk.Rectangle) range_rect+    touchManagedPtr _obj+    return range_rect'++-- method Range::get_restrict_to_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_restrict_to_fill_level" gtk_range_get_restrict_to_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CInt+++rangeGetRestrictToFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Bool+rangeGetRestrictToFillLevel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_restrict_to_fill_level _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Range::get_round_digits+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_round_digits" gtk_range_get_round_digits :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO Int32+++rangeGetRoundDigits ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Int32+rangeGetRoundDigits _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_round_digits _obj'+    touchManagedPtr _obj+    return result++-- method Range::get_show_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_show_fill_level" gtk_range_get_show_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CInt+++rangeGetShowFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Bool+rangeGetShowFillLevel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_show_fill_level _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Range::get_slider_range+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "slider_start", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "slider_end", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_slider_range" gtk_range_get_slider_range :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    Ptr Int32 ->                            -- slider_start : TBasicType TInt32+    Ptr Int32 ->                            -- slider_end : TBasicType TInt32+    IO ()+++rangeGetSliderRange ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m (Int32,Int32)+rangeGetSliderRange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    slider_start <- allocMem :: IO (Ptr Int32)+    slider_end <- allocMem :: IO (Ptr Int32)+    gtk_range_get_slider_range _obj' slider_start slider_end+    slider_start' <- peek slider_start+    slider_end' <- peek slider_end+    touchManagedPtr _obj+    freeMem slider_start+    freeMem slider_end+    return (slider_start', slider_end')++-- method Range::get_slider_size_fixed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_slider_size_fixed" gtk_range_get_slider_size_fixed :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CInt+++rangeGetSliderSizeFixed ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Bool+rangeGetSliderSizeFixed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_slider_size_fixed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Range::get_upper_stepper_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "SensitivityType"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_upper_stepper_sensitivity" gtk_range_get_upper_stepper_sensitivity :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CUInt+++rangeGetUpperStepperSensitivity ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m SensitivityType+rangeGetUpperStepperSensitivity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_upper_stepper_sensitivity _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Range::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_get_value" gtk_range_get_value :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    IO CDouble+++rangeGetValue ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    m Double+rangeGetValue _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_range_get_value _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Range::set_adjustment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "adjustment", argType = TInterface "Gtk" "Adjustment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_adjustment" gtk_range_set_adjustment :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    Ptr Adjustment ->                       -- adjustment : TInterface "Gtk" "Adjustment"+    IO ()+++rangeSetAdjustment ::+    (MonadIO m, RangeK a, AdjustmentK b) =>+    a ->                                    -- _obj+    b ->                                    -- adjustment+    m ()+rangeSetAdjustment _obj adjustment = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let adjustment' = unsafeManagedPtrCastPtr adjustment+    gtk_range_set_adjustment _obj' adjustment'+    touchManagedPtr _obj+    touchManagedPtr adjustment+    return ()++-- method Range::set_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill_level", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fill_level", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_fill_level" gtk_range_set_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CDouble ->                              -- fill_level : TBasicType TDouble+    IO ()+++rangeSetFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Double ->                               -- fill_level+    m ()+rangeSetFillLevel _obj fill_level = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let fill_level' = realToFrac fill_level+    gtk_range_set_fill_level _obj' fill_level'+    touchManagedPtr _obj+    return ()++-- method Range::set_flippable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flippable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flippable", 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 "gtk_range_set_flippable" gtk_range_set_flippable :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CInt ->                                 -- flippable : TBasicType TBoolean+    IO ()+++rangeSetFlippable ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- flippable+    m ()+rangeSetFlippable _obj flippable = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flippable' = (fromIntegral . fromEnum) flippable+    gtk_range_set_flippable _obj' flippable'+    touchManagedPtr _obj+    return ()++-- method Range::set_increments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "step", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "page", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_increments" gtk_range_set_increments :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CDouble ->                              -- step : TBasicType TDouble+    CDouble ->                              -- page : TBasicType TDouble+    IO ()+++rangeSetIncrements ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Double ->                               -- step+    Double ->                               -- page+    m ()+rangeSetIncrements _obj step page = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let step' = realToFrac step+    let page' = realToFrac page+    gtk_range_set_increments _obj' step' page'+    touchManagedPtr _obj+    return ()++-- method Range::set_inverted+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "setting", 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 "gtk_range_set_inverted" gtk_range_set_inverted :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CInt ->                                 -- setting : TBasicType TBoolean+    IO ()+++rangeSetInverted ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- setting+    m ()+rangeSetInverted _obj setting = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let setting' = (fromIntegral . fromEnum) setting+    gtk_range_set_inverted _obj' setting'+    touchManagedPtr _obj+    return ()++-- method Range::set_lower_stepper_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_lower_stepper_sensitivity" gtk_range_set_lower_stepper_sensitivity :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CUInt ->                                -- sensitivity : TInterface "Gtk" "SensitivityType"+    IO ()+++rangeSetLowerStepperSensitivity ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    SensitivityType ->                      -- sensitivity+    m ()+rangeSetLowerStepperSensitivity _obj sensitivity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitivity' = (fromIntegral . fromEnum) sensitivity+    gtk_range_set_lower_stepper_sensitivity _obj' sensitivity'+    touchManagedPtr _obj+    return ()++-- method Range::set_min_slider_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_size", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min_size", 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 "gtk_range_set_min_slider_size" gtk_range_set_min_slider_size :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    Int32 ->                                -- min_size : TBasicType TInt32+    IO ()+++rangeSetMinSliderSize ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- min_size+    m ()+rangeSetMinSliderSize _obj min_size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_range_set_min_slider_size _obj' min_size+    touchManagedPtr _obj+    return ()++-- method Range::set_range+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "min", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "max", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_range" gtk_range_set_range :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CDouble ->                              -- min : TBasicType TDouble+    CDouble ->                              -- max : TBasicType TDouble+    IO ()+++rangeSetRange ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Double ->                               -- min+    Double ->                               -- max+    m ()+rangeSetRange _obj min max = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let min' = realToFrac min+    let max' = realToFrac max+    gtk_range_set_range _obj' min' max'+    touchManagedPtr _obj+    return ()++-- method Range::set_restrict_to_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "restrict_to_fill_level", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "restrict_to_fill_level", 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 "gtk_range_set_restrict_to_fill_level" gtk_range_set_restrict_to_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CInt ->                                 -- restrict_to_fill_level : TBasicType TBoolean+    IO ()+++rangeSetRestrictToFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- restrict_to_fill_level+    m ()+rangeSetRestrictToFillLevel _obj restrict_to_fill_level = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let restrict_to_fill_level' = (fromIntegral . fromEnum) restrict_to_fill_level+    gtk_range_set_restrict_to_fill_level _obj' restrict_to_fill_level'+    touchManagedPtr _obj+    return ()++-- method Range::set_round_digits+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "round_digits", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "round_digits", 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 "gtk_range_set_round_digits" gtk_range_set_round_digits :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    Int32 ->                                -- round_digits : TBasicType TInt32+    IO ()+++rangeSetRoundDigits ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- round_digits+    m ()+rangeSetRoundDigits _obj round_digits = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gtk_range_set_round_digits _obj' round_digits+    touchManagedPtr _obj+    return ()++-- method Range::set_show_fill_level+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_fill_level", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_fill_level", 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 "gtk_range_set_show_fill_level" gtk_range_set_show_fill_level :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CInt ->                                 -- show_fill_level : TBasicType TBoolean+    IO ()+++rangeSetShowFillLevel ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_fill_level+    m ()+rangeSetShowFillLevel _obj show_fill_level = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_fill_level' = (fromIntegral . fromEnum) show_fill_level+    gtk_range_set_show_fill_level _obj' show_fill_level'+    touchManagedPtr _obj+    return ()++-- method Range::set_slider_size_fixed+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size_fixed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "size_fixed", 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 "gtk_range_set_slider_size_fixed" gtk_range_set_slider_size_fixed :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CInt ->                                 -- size_fixed : TBasicType TBoolean+    IO ()+++rangeSetSliderSizeFixed ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- size_fixed+    m ()+rangeSetSliderSizeFixed _obj size_fixed = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let size_fixed' = (fromIntegral . fromEnum) size_fixed+    gtk_range_set_slider_size_fixed _obj' size_fixed'+    touchManagedPtr _obj+    return ()++-- method Range::set_upper_stepper_sensitivity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "sensitivity", argType = TInterface "Gtk" "SensitivityType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_upper_stepper_sensitivity" gtk_range_set_upper_stepper_sensitivity :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CUInt ->                                -- sensitivity : TInterface "Gtk" "SensitivityType"+    IO ()+++rangeSetUpperStepperSensitivity ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    SensitivityType ->                      -- sensitivity+    m ()+rangeSetUpperStepperSensitivity _obj sensitivity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sensitivity' = (fromIntegral . fromEnum) sensitivity+    gtk_range_set_upper_stepper_sensitivity _obj' sensitivity'+    touchManagedPtr _obj+    return ()++-- method Range::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "Range", 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 "Gtk" "Range", 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 TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gtk_range_set_value" gtk_range_set_value :: +    Ptr Range ->                            -- _obj : TInterface "Gtk" "Range"+    CDouble ->                              -- value : TBasicType TDouble+    IO ()+++rangeSetValue ::+    (MonadIO m, RangeK a) =>+    a ->                                    -- _obj+    Double ->                               -- value+    m ()+rangeSetValue _obj value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    gtk_range_set_value _obj' value'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/Range.hs-boot view
@@ -0,0 +1,25 @@+module GI.Gtk.Objects.Range where++import Prelude ()+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 Range = Range (ForeignPtr Range)+instance GObject Range where+class GObject o => RangeK o+instance (GObject o, IsDescendantOf Range o) => RangeK o+data RangeAdjustmentPropertyInfo+data RangeFillLevelPropertyInfo+data RangeInvertedPropertyInfo+data RangeLowerStepperSensitivityPropertyInfo+data RangeRestrictToFillLevelPropertyInfo+data RangeRoundDigitsPropertyInfo+data RangeShowFillLevelPropertyInfo+data RangeUpperStepperSensitivityPropertyInfo+data RangeAdjustBoundsSignalInfo+data RangeChangeValueSignalInfo+data RangeMoveSliderSignalInfo+data RangeValueChangedSignalInfo
+ GI/Gtk/Objects/RangeAccessible.hs view
@@ -0,0 +1,59 @@++{- |+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.Gtk.Objects.RangeAccessible+    ( ++-- * Exported types+    RangeAccessible(..)                     ,+    RangeAccessibleK                        ,+    toRangeAccessible                       ,+    noRangeAccessible                       ,+++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.Atk as Atk+import qualified GI.GObject as GObject++newtype RangeAccessible = RangeAccessible (ForeignPtr RangeAccessible)+foreign import ccall "gtk_range_accessible_get_type"+    c_gtk_range_accessible_get_type :: IO GType++type instance ParentTypes RangeAccessible = RangeAccessibleParentTypes+type RangeAccessibleParentTypes = '[WidgetAccessible, Accessible, Atk.Object, GObject.Object, Atk.Component, Atk.Value]++instance GObject RangeAccessible where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_range_accessible_get_type+    ++class GObject o => RangeAccessibleK o+instance (GObject o, IsDescendantOf RangeAccessible o) => RangeAccessibleK o++toRangeAccessible :: RangeAccessibleK o => o -> IO RangeAccessible+toRangeAccessible = unsafeCastTo RangeAccessible++noRangeAccessible :: Maybe RangeAccessible+noRangeAccessible = Nothing++type instance AttributeList RangeAccessible = RangeAccessibleAttributeList+type RangeAccessibleAttributeList = ('[ '("accessible-component-layer", Atk.ObjectAccessibleComponentLayerPropertyInfo), '("accessible-component-mdi-zorder", Atk.ObjectAccessibleComponentMdiZorderPropertyInfo), '("accessible-description", Atk.ObjectAccessibleDescriptionPropertyInfo), '("accessible-hypertext-nlinks", Atk.ObjectAccessibleHypertextNlinksPropertyInfo), '("accessible-name", Atk.ObjectAccessibleNamePropertyInfo), '("accessible-parent", Atk.ObjectAccessibleParentPropertyInfo), '("accessible-role", Atk.ObjectAccessibleRolePropertyInfo), '("accessible-table-caption", Atk.ObjectAccessibleTableCaptionPropertyInfo), '("accessible-table-caption-object", Atk.ObjectAccessibleTableCaptionObjectPropertyInfo), '("accessible-table-column-description", Atk.ObjectAccessibleTableColumnDescriptionPropertyInfo), '("accessible-table-column-header", Atk.ObjectAccessibleTableColumnHeaderPropertyInfo), '("accessible-table-row-description", Atk.ObjectAccessibleTableRowDescriptionPropertyInfo), '("accessible-table-row-header", Atk.ObjectAccessibleTableRowHeaderPropertyInfo), '("accessible-table-summary", Atk.ObjectAccessibleTableSummaryPropertyInfo), '("accessible-value", Atk.ObjectAccessibleValuePropertyInfo), '("widget", AccessibleWidgetPropertyInfo)] :: [(Symbol, *)])++type instance SignalList RangeAccessible = RangeAccessibleSignalList+type RangeAccessibleSignalList = ('[ '("active-descendant-changed", Atk.ObjectActiveDescendantChangedSignalInfo), '("bounds-changed", Atk.ComponentBoundsChangedSignalInfo), '("children-changed", Atk.ObjectChildrenChangedSignalInfo), '("focus-event", Atk.ObjectFocusEventSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("property-change", Atk.ObjectPropertyChangeSignalInfo), '("state-change", Atk.ObjectStateChangeSignalInfo), '("value-changed", Atk.ValueValueChangedSignalInfo), '("visible-data-changed", Atk.ObjectVisibleDataChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++
+ GI/Gtk/Objects/RangeAccessible.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.RangeAccessible where++import Prelude ()+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 RangeAccessible = RangeAccessible (ForeignPtr RangeAccessible)+instance GObject RangeAccessible where+class GObject o => RangeAccessibleK o+instance (GObject o, IsDescendantOf RangeAccessible o) => RangeAccessibleK o
+ GI/Gtk/Objects/RcStyle.hs view
@@ -0,0 +1,117 @@++{- |+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.Gtk.Objects.RcStyle+    ( ++-- * Exported types+    RcStyle(..)                             ,+    RcStyleK                                ,+    toRcStyle                               ,+    noRcStyle                               ,+++ -- * Methods+-- ** rcStyleCopy+    rcStyleCopy                             ,+++-- ** rcStyleNew+    rcStyleNew                              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype RcStyle = RcStyle (ForeignPtr RcStyle)+foreign import ccall "gtk_rc_style_get_type"+    c_gtk_rc_style_get_type :: IO GType++type instance ParentTypes RcStyle = RcStyleParentTypes+type RcStyleParentTypes = '[GObject.Object]++instance GObject RcStyle where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_rc_style_get_type+    ++class GObject o => RcStyleK o+instance (GObject o, IsDescendantOf RcStyle o) => RcStyleK o++toRcStyle :: RcStyleK o => o -> IO RcStyle+toRcStyle = unsafeCastTo RcStyle++noRcStyle :: Maybe RcStyle+noRcStyle = Nothing++type instance AttributeList RcStyle = RcStyleAttributeList+type RcStyleAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList RcStyle = RcStyleSignalList+type RcStyleSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RcStyle::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Gtk" "RcStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_style_new" gtk_rc_style_new :: +    IO (Ptr RcStyle)++{-# DEPRECATED rcStyleNew ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcStyleNew ::+    (MonadIO m) =>+    m RcStyle+rcStyleNew  = liftIO $ do+    result <- gtk_rc_style_new+    checkUnexpectedReturnNULL "gtk_rc_style_new" result+    result' <- (wrapObject RcStyle) result+    return result'++-- method RcStyle::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RcStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RcStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RcStyle"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_rc_style_copy" gtk_rc_style_copy :: +    Ptr RcStyle ->                          -- _obj : TInterface "Gtk" "RcStyle"+    IO (Ptr RcStyle)++{-# DEPRECATED rcStyleCopy ["(Since version 3.0)","Use #GtkCssProvider instead."]#-}+rcStyleCopy ::+    (MonadIO m, RcStyleK a) =>+    a ->                                    -- _obj+    m RcStyle+rcStyleCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_rc_style_copy _obj'+    checkUnexpectedReturnNULL "gtk_rc_style_copy" result+    result' <- (wrapObject RcStyle) result+    touchManagedPtr _obj+    return result'++
+ GI/Gtk/Objects/RcStyle.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gtk.Objects.RcStyle where++import Prelude ()+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 RcStyle = RcStyle (ForeignPtr RcStyle)+instance GObject RcStyle where+class GObject o => RcStyleK o+instance (GObject o, IsDescendantOf RcStyle o) => RcStyleK o
+ GI/Gtk/Objects/RecentAction.hs view
@@ -0,0 +1,271 @@++{- |+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.Gtk.Objects.RecentAction+    ( ++-- * Exported types+    RecentAction(..)                        ,+    RecentActionK                           ,+    toRecentAction                          ,+    noRecentAction                          ,+++ -- * Methods+-- ** recentActionGetShowNumbers+    recentActionGetShowNumbers              ,+++-- ** recentActionNew+    recentActionNew                         ,+++-- ** recentActionNewForManager+    recentActionNewForManager               ,+++-- ** recentActionSetShowNumbers+    recentActionSetShowNumbers              ,+++++ -- * Properties+-- ** ShowNumbers+    RecentActionShowNumbersPropertyInfo     ,+    constructRecentActionShowNumbers        ,+    getRecentActionShowNumbers              ,+    setRecentActionShowNumbers              ,+++++    ) where++import Prelude ()+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.Gtk.Types+import GI.Gtk.Callbacks+import qualified GI.GObject as GObject++newtype RecentAction = RecentAction (ForeignPtr RecentAction)+foreign import ccall "gtk_recent_action_get_type"+    c_gtk_recent_action_get_type :: IO GType++type instance ParentTypes RecentAction = RecentActionParentTypes+type RecentActionParentTypes = '[Action, GObject.Object, Buildable, RecentChooser]++instance GObject RecentAction where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gtk_recent_action_get_type+    ++class GObject o => RecentActionK o+instance (GObject o, IsDescendantOf RecentAction o) => RecentActionK o++toRecentAction :: RecentActionK o => o -> IO RecentAction+toRecentAction = unsafeCastTo RecentAction++noRecentAction :: Maybe RecentAction+noRecentAction = Nothing++-- VVV Prop "show-numbers"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getRecentActionShowNumbers :: (MonadIO m, RecentActionK o) => o -> m Bool+getRecentActionShowNumbers obj = liftIO $ getObjectPropertyBool obj "show-numbers"++setRecentActionShowNumbers :: (MonadIO m, RecentActionK o) => o -> Bool -> m ()+setRecentActionShowNumbers obj val = liftIO $ setObjectPropertyBool obj "show-numbers" val++constructRecentActionShowNumbers :: Bool -> IO ([Char], GValue)+constructRecentActionShowNumbers val = constructObjectPropertyBool "show-numbers" val++data RecentActionShowNumbersPropertyInfo+instance AttrInfo RecentActionShowNumbersPropertyInfo where+    type AttrAllowedOps RecentActionShowNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint RecentActionShowNumbersPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint RecentActionShowNumbersPropertyInfo = RecentActionK+    type AttrGetType RecentActionShowNumbersPropertyInfo = Bool+    type AttrLabel RecentActionShowNumbersPropertyInfo = "RecentAction::show-numbers"+    attrGet _ = getRecentActionShowNumbers+    attrSet _ = setRecentActionShowNumbers+    attrConstruct _ = constructRecentActionShowNumbers++type instance AttributeList RecentAction = RecentActionAttributeList+type RecentActionAttributeList = ('[ '("action-group", ActionActionGroupPropertyInfo), '("always-show-image", ActionAlwaysShowImagePropertyInfo), '("filter", RecentChooserFilterPropertyInfo), '("gicon", ActionGiconPropertyInfo), '("hide-if-empty", ActionHideIfEmptyPropertyInfo), '("icon-name", ActionIconNamePropertyInfo), '("is-important", ActionIsImportantPropertyInfo), '("label", ActionLabelPropertyInfo), '("limit", RecentChooserLimitPropertyInfo), '("local-only", RecentChooserLocalOnlyPropertyInfo), '("name", ActionNamePropertyInfo), '("recent-manager", RecentChooserRecentManagerPropertyInfo), '("select-multiple", RecentChooserSelectMultiplePropertyInfo), '("sensitive", ActionSensitivePropertyInfo), '("short-label", ActionShortLabelPropertyInfo), '("show-icons", RecentChooserShowIconsPropertyInfo), '("show-not-found", RecentChooserShowNotFoundPropertyInfo), '("show-numbers", RecentActionShowNumbersPropertyInfo), '("show-private", RecentChooserShowPrivatePropertyInfo), '("show-tips", RecentChooserShowTipsPropertyInfo), '("sort-type", RecentChooserSortTypePropertyInfo), '("stock-id", ActionStockIdPropertyInfo), '("tooltip", ActionTooltipPropertyInfo), '("visible", ActionVisiblePropertyInfo), '("visible-horizontal", ActionVisibleHorizontalPropertyInfo), '("visible-overflown", ActionVisibleOverflownPropertyInfo), '("visible-vertical", ActionVisibleVerticalPropertyInfo)] :: [(Symbol, *)])++type instance SignalList RecentAction = RecentActionSignalList+type RecentActionSignalList = ('[ '("activate", ActionActivateSignalInfo), '("item-activated", RecentChooserItemActivatedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("selection-changed", RecentChooserSelectionChangedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method RecentAction::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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, 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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RecentAction"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_action_new" gtk_recent_action_new :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- tooltip : TBasicType TUTF8+    CString ->                              -- stock_id : TBasicType TUTF8+    IO (Ptr RecentAction)++{-# DEPRECATED recentActionNew ["(Since version 3.10)"]#-}+recentActionNew ::+    (MonadIO m) =>+    T.Text ->                               -- name+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- tooltip+    Maybe (T.Text) ->                       -- stock_id+    m RecentAction+recentActionNew name label tooltip stock_id = liftIO $ do+    name' <- textToCString name+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    maybeStock_id <- case stock_id of+        Nothing -> return nullPtr+        Just jStock_id -> do+            jStock_id' <- textToCString jStock_id+            return jStock_id'+    result <- gtk_recent_action_new name' maybeLabel maybeTooltip maybeStock_id+    checkUnexpectedReturnNULL "gtk_recent_action_new" result+    result' <- (wrapObject RecentAction) result+    freeMem name'+    freeMem maybeLabel+    freeMem maybeTooltip+    freeMem maybeStock_id+    return result'++-- method RecentAction::new_for_manager+-- method type : Constructor+-- Args : [Arg {argName = "name", argType = TBasicType TUTF8, 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 = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "manager", argType = TInterface "Gtk" "RecentManager", 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 = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "tooltip", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "manager", argType = TInterface "Gtk" "RecentManager", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Gtk" "RecentAction"+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_action_new_for_manager" gtk_recent_action_new_for_manager :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- label : TBasicType TUTF8+    CString ->                              -- tooltip : TBasicType TUTF8+    CString ->                              -- stock_id : TBasicType TUTF8+    Ptr RecentManager ->                    -- manager : TInterface "Gtk" "RecentManager"+    IO (Ptr RecentAction)++{-# DEPRECATED recentActionNewForManager ["(Since version 3.10)"]#-}+recentActionNewForManager ::+    (MonadIO m, RecentManagerK a) =>+    T.Text ->                               -- name+    Maybe (T.Text) ->                       -- label+    Maybe (T.Text) ->                       -- tooltip+    Maybe (T.Text) ->                       -- stock_id+    Maybe (a) ->                            -- manager+    m RecentAction+recentActionNewForManager name label tooltip stock_id manager = liftIO $ do+    name' <- textToCString name+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    maybeTooltip <- case tooltip of+        Nothing -> return nullPtr+        Just jTooltip -> do+            jTooltip' <- textToCString jTooltip+            return jTooltip'+    maybeStock_id <- case stock_id of+        Nothing -> return nullPtr+        Just jStock_id -> do+            jStock_id' <- textToCString jStock_id+            return jStock_id'+    maybeManager <- case manager of+        Nothing -> return nullPtr+        Just jManager -> do+            let jManager' = unsafeManagedPtrCastPtr jManager+            return jManager'+    result <- gtk_recent_action_new_for_manager name' maybeLabel maybeTooltip maybeStock_id maybeManager+    checkUnexpectedReturnNULL "gtk_recent_action_new_for_manager" result+    result' <- (wrapObject RecentAction) result+    whenJust manager touchManagedPtr+    freeMem name'+    freeMem maybeLabel+    freeMem maybeTooltip+    freeMem maybeStock_id+    return result'++-- method RecentAction::get_show_numbers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gtk_recent_action_get_show_numbers" gtk_recent_action_get_show_numbers :: +    Ptr RecentAction ->                     -- _obj : TInterface "Gtk" "RecentAction"+    IO CInt++{-# DEPRECATED recentActionGetShowNumbers ["(Since version 3.10)"]#-}+recentActionGetShowNumbers ::+    (MonadIO m, RecentActionK a) =>+    a ->                                    -- _obj+    m Bool+recentActionGetShowNumbers _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gtk_recent_action_get_show_numbers _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method RecentAction::set_show_numbers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_numbers", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Gtk" "RecentAction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "show_numbers", 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 "gtk_recent_action_set_show_numbers" gtk_recent_action_set_show_numbers :: +    Ptr RecentAction ->                     -- _obj : TInterface "Gtk" "RecentAction"+    CInt ->                                 -- show_numbers : TBasicType TBoolean+    IO ()++{-# DEPRECATED recentActionSetShowNumbers ["(Since version 3.10)"]#-}+recentActionSetShowNumbers ::+    (MonadIO m, RecentActionK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- show_numbers+    m ()+recentActionSetShowNumbers _obj show_numbers = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let show_numbers' = (fromIntegral . fromEnum) show_numbers+    gtk_recent_action_set_show_numbers _obj' show_numbers'+    touchManagedPtr _obj+    return ()++
+ GI/Gtk/Objects/RecentAction.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gtk.Objects.RecentAction where++import Prelude ()+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 RecentAction = RecentAction (ForeignPtr RecentAction)+instance GObject RecentAction where+class GObject o => RecentActionK o+instance (GObject o, IsDescendantOf RecentAction o) => RecentActionK o+data RecentActionShowNumbersPropertyInfo
+ GI/Gtk/Objects/RecentChooserDialog.hs view

file too large to diff

+ GI/Gtk/Objects/RecentChooserDialog.hs-boot view

file too large to diff

+ GI/Gtk/Objects/RecentChooserMenu.hs view

file too large to diff

+ GI/Gtk/Objects/RecentChooserMenu.hs-boot view

file too large to diff

+ GI/Gtk/Objects/RecentChooserWidget.hs view

file too large to diff

+ GI/Gtk/Objects/RecentChooserWidget.hs-boot view

file too large to diff

+ GI/Gtk/Objects/RecentFilter.hs view

file too large to diff

+ GI/Gtk/Objects/RecentFilter.hs-boot view

file too large to diff

+ GI/Gtk/Objects/RecentManager.hs view

file too large to diff

+ GI/Gtk/Objects/RecentManager.hs-boot view

file too large to diff

+ GI/Gtk/Objects/RendererCellAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/RendererCellAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Revealer.hs view

file too large to diff

+ GI/Gtk/Objects/Revealer.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Scale.hs view

file too large to diff

+ GI/Gtk/Objects/Scale.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ScaleAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/ScaleAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ScaleButton.hs view

file too large to diff

+ GI/Gtk/Objects/ScaleButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ScaleButtonAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/ScaleButtonAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Scrollbar.hs view

file too large to diff

+ GI/Gtk/Objects/Scrollbar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ScrolledWindow.hs view

file too large to diff

+ GI/Gtk/Objects/ScrolledWindow.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ScrolledWindowAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/ScrolledWindowAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SearchBar.hs view

file too large to diff

+ GI/Gtk/Objects/SearchBar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SearchEntry.hs view

file too large to diff

+ GI/Gtk/Objects/SearchEntry.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Separator.hs view

file too large to diff

+ GI/Gtk/Objects/Separator.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SeparatorMenuItem.hs view

file too large to diff

+ GI/Gtk/Objects/SeparatorMenuItem.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SeparatorToolItem.hs view

file too large to diff

+ GI/Gtk/Objects/SeparatorToolItem.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Settings.hs view

file too large to diff

+ GI/Gtk/Objects/Settings.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SizeGroup.hs view

file too large to diff

+ GI/Gtk/Objects/SizeGroup.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Socket.hs view

file too large to diff

+ GI/Gtk/Objects/Socket.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SpinButton.hs view

file too large to diff

+ GI/Gtk/Objects/SpinButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SpinButtonAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/SpinButtonAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Spinner.hs view

file too large to diff

+ GI/Gtk/Objects/Spinner.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SpinnerAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/SpinnerAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Stack.hs view

file too large to diff

+ GI/Gtk/Objects/Stack.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StackSidebar.hs view

file too large to diff

+ GI/Gtk/Objects/StackSidebar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StackSwitcher.hs view

file too large to diff

+ GI/Gtk/Objects/StackSwitcher.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StatusIcon.hs view

file too large to diff

+ GI/Gtk/Objects/StatusIcon.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Statusbar.hs view

file too large to diff

+ GI/Gtk/Objects/Statusbar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StatusbarAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/StatusbarAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Style.hs view

file too large to diff

+ GI/Gtk/Objects/Style.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StyleContext.hs view

file too large to diff

+ GI/Gtk/Objects/StyleContext.hs-boot view

file too large to diff

+ GI/Gtk/Objects/StyleProperties.hs view

file too large to diff

+ GI/Gtk/Objects/StyleProperties.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Switch.hs view

file too large to diff

+ GI/Gtk/Objects/Switch.hs-boot view

file too large to diff

+ GI/Gtk/Objects/SwitchAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/SwitchAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Table.hs view

file too large to diff

+ GI/Gtk/Objects/Table.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TearoffMenuItem.hs view

file too large to diff

+ GI/Gtk/Objects/TearoffMenuItem.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextBuffer.hs view

file too large to diff

+ GI/Gtk/Objects/TextBuffer.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextCellAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/TextCellAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextChildAnchor.hs view

file too large to diff

+ GI/Gtk/Objects/TextChildAnchor.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextMark.hs view

file too large to diff

+ GI/Gtk/Objects/TextMark.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextTag.hs view

file too large to diff

+ GI/Gtk/Objects/TextTag.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextTagTable.hs view

file too large to diff

+ GI/Gtk/Objects/TextTagTable.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextView.hs view

file too large to diff

+ GI/Gtk/Objects/TextView.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TextViewAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/TextViewAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ThemingEngine.hs view

file too large to diff

+ GI/Gtk/Objects/ThemingEngine.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToggleAction.hs view

file too large to diff

+ GI/Gtk/Objects/ToggleAction.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToggleButton.hs view

file too large to diff

+ GI/Gtk/Objects/ToggleButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToggleButtonAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/ToggleButtonAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToggleToolButton.hs view

file too large to diff

+ GI/Gtk/Objects/ToggleToolButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToolButton.hs view

file too large to diff

+ GI/Gtk/Objects/ToolButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToolItem.hs view

file too large to diff

+ GI/Gtk/Objects/ToolItem.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToolItemGroup.hs view

file too large to diff

+ GI/Gtk/Objects/ToolItemGroup.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToolPalette.hs view

file too large to diff

+ GI/Gtk/Objects/ToolPalette.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Toolbar.hs view

file too large to diff

+ GI/Gtk/Objects/Toolbar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Tooltip.hs view

file too large to diff

+ GI/Gtk/Objects/Tooltip.hs-boot view

file too large to diff

+ GI/Gtk/Objects/ToplevelAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/ToplevelAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeModelFilter.hs view

file too large to diff

+ GI/Gtk/Objects/TreeModelFilter.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeModelSort.hs view

file too large to diff

+ GI/Gtk/Objects/TreeModelSort.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeSelection.hs view

file too large to diff

+ GI/Gtk/Objects/TreeSelection.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeStore.hs view

file too large to diff

+ GI/Gtk/Objects/TreeStore.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeView.hs view

file too large to diff

+ GI/Gtk/Objects/TreeView.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeViewAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/TreeViewAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/TreeViewColumn.hs view

file too large to diff

+ GI/Gtk/Objects/TreeViewColumn.hs-boot view

file too large to diff

+ GI/Gtk/Objects/UIManager.hs view

file too large to diff

+ GI/Gtk/Objects/UIManager.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VBox.hs view

file too large to diff

+ GI/Gtk/Objects/VBox.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VButtonBox.hs view

file too large to diff

+ GI/Gtk/Objects/VButtonBox.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VPaned.hs view

file too large to diff

+ GI/Gtk/Objects/VPaned.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VScale.hs view

file too large to diff

+ GI/Gtk/Objects/VScale.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VScrollbar.hs view

file too large to diff

+ GI/Gtk/Objects/VScrollbar.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VSeparator.hs view

file too large to diff

+ GI/Gtk/Objects/VSeparator.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Viewport.hs view

file too large to diff

+ GI/Gtk/Objects/Viewport.hs-boot view

file too large to diff

+ GI/Gtk/Objects/VolumeButton.hs view

file too large to diff

+ GI/Gtk/Objects/VolumeButton.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Widget.hs view

file too large to diff

+ GI/Gtk/Objects/Widget.hs-boot view

file too large to diff

+ GI/Gtk/Objects/WidgetAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/WidgetAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/Window.hs view

file too large to diff

+ GI/Gtk/Objects/Window.hs-boot view

file too large to diff

+ GI/Gtk/Objects/WindowAccessible.hs view

file too large to diff

+ GI/Gtk/Objects/WindowAccessible.hs-boot view

file too large to diff

+ GI/Gtk/Objects/WindowGroup.hs view

file too large to diff

+ GI/Gtk/Objects/WindowGroup.hs-boot view

file too large to diff

+ GI/Gtk/Structs.hs view

file too large to diff

+ GI/Gtk/Structs/AccelGroupEntry.hs view

file too large to diff

+ GI/Gtk/Structs/AccelGroupEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/AccelKey.hs view

file too large to diff

+ GI/Gtk/Structs/AccelKey.hs-boot view

file too large to diff

+ GI/Gtk/Structs/ActionEntry.hs view

file too large to diff

+ GI/Gtk/Structs/ActionEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/BindingArg.hs view

file too large to diff

+ GI/Gtk/Structs/BindingArg.hs-boot view

file too large to diff

+ GI/Gtk/Structs/BindingEntry.hs view

file too large to diff

+ GI/Gtk/Structs/BindingEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/BindingSet.hs view

file too large to diff

+ GI/Gtk/Structs/BindingSet.hs-boot view

file too large to diff

+ GI/Gtk/Structs/BindingSignal.hs view

file too large to diff

+ GI/Gtk/Structs/BindingSignal.hs-boot view

file too large to diff

+ GI/Gtk/Structs/Border.hs view

file too large to diff

+ GI/Gtk/Structs/Border.hs-boot view

file too large to diff

+ GI/Gtk/Structs/CssSection.hs view

file too large to diff

+ GI/Gtk/Structs/CssSection.hs-boot view

file too large to diff

+ GI/Gtk/Structs/FileFilterInfo.hs view

file too large to diff

+ GI/Gtk/Structs/FileFilterInfo.hs-boot view

file too large to diff

+ GI/Gtk/Structs/FixedChild.hs view

file too large to diff

+ GI/Gtk/Structs/FixedChild.hs-boot view

file too large to diff

+ GI/Gtk/Structs/Gradient.hs view

file too large to diff

+ GI/Gtk/Structs/Gradient.hs-boot view

file too large to diff

+ GI/Gtk/Structs/IMContextInfo.hs view

file too large to diff

+ GI/Gtk/Structs/IMContextInfo.hs-boot view

file too large to diff

+ GI/Gtk/Structs/IconSet.hs view

file too large to diff

+ GI/Gtk/Structs/IconSet.hs-boot view

file too large to diff

+ GI/Gtk/Structs/IconSource.hs view

file too large to diff

+ GI/Gtk/Structs/IconSource.hs-boot view

file too large to diff

+ GI/Gtk/Structs/LabelSelectionInfo.hs view

file too large to diff

+ GI/Gtk/Structs/LabelSelectionInfo.hs-boot view

file too large to diff

+ GI/Gtk/Structs/PageRange.hs view

file too large to diff

+ GI/Gtk/Structs/PageRange.hs-boot view

file too large to diff

+ GI/Gtk/Structs/PaperSize.hs view

file too large to diff

+ GI/Gtk/Structs/PaperSize.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RadioActionEntry.hs view

file too large to diff

+ GI/Gtk/Structs/RadioActionEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RcContext.hs view

file too large to diff

+ GI/Gtk/Structs/RcContext.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RcProperty.hs view

file too large to diff

+ GI/Gtk/Structs/RcProperty.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RecentData.hs view

file too large to diff

+ GI/Gtk/Structs/RecentData.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RecentFilterInfo.hs view

file too large to diff

+ GI/Gtk/Structs/RecentFilterInfo.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RecentInfo.hs view

file too large to diff

+ GI/Gtk/Structs/RecentInfo.hs-boot view

file too large to diff

+ GI/Gtk/Structs/RequestedSize.hs view

file too large to diff

+ GI/Gtk/Structs/RequestedSize.hs-boot view

file too large to diff

+ GI/Gtk/Structs/Requisition.hs view

file too large to diff

+ GI/Gtk/Structs/Requisition.hs-boot view

file too large to diff

+ GI/Gtk/Structs/SelectionData.hs view

file too large to diff

+ GI/Gtk/Structs/SelectionData.hs-boot view

file too large to diff

+ GI/Gtk/Structs/SettingsValue.hs view

file too large to diff

+ GI/Gtk/Structs/SettingsValue.hs-boot view

file too large to diff

+ GI/Gtk/Structs/StockItem.hs view

file too large to diff

+ GI/Gtk/Structs/StockItem.hs-boot view

file too large to diff

+ GI/Gtk/Structs/SymbolicColor.hs view

file too large to diff

+ GI/Gtk/Structs/SymbolicColor.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TableChild.hs view

file too large to diff

+ GI/Gtk/Structs/TableChild.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TableRowCol.hs view

file too large to diff

+ GI/Gtk/Structs/TableRowCol.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TargetEntry.hs view

file too large to diff

+ GI/Gtk/Structs/TargetEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TargetList.hs view

file too large to diff

+ GI/Gtk/Structs/TargetList.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TargetPair.hs view

file too large to diff

+ GI/Gtk/Structs/TargetPair.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TextAppearance.hs view

file too large to diff

+ GI/Gtk/Structs/TextAppearance.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TextAttributes.hs view

file too large to diff

+ GI/Gtk/Structs/TextAttributes.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TextBTree.hs view

file too large to diff

+ GI/Gtk/Structs/TextBTree.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TextIter.hs view

file too large to diff

+ GI/Gtk/Structs/TextIter.hs-boot view

file too large to diff

+ GI/Gtk/Structs/ThemeEngine.hs view

file too large to diff

+ GI/Gtk/Structs/ThemeEngine.hs-boot view

file too large to diff

+ GI/Gtk/Structs/ToggleActionEntry.hs view

file too large to diff

+ GI/Gtk/Structs/ToggleActionEntry.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TreeIter.hs view

file too large to diff

+ GI/Gtk/Structs/TreeIter.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TreePath.hs view

file too large to diff

+ GI/Gtk/Structs/TreePath.hs-boot view

file too large to diff

+ GI/Gtk/Structs/TreeRowReference.hs view

file too large to diff

+ GI/Gtk/Structs/TreeRowReference.hs-boot view

file too large to diff

+ GI/Gtk/Structs/WidgetPath.hs view

file too large to diff

+ GI/Gtk/Structs/WidgetPath.hs-boot view

file too large to diff

+ GI/Gtk/Structs/WindowGeometryInfo.hs view

file too large to diff

+ GI/Gtk/Structs/WindowGeometryInfo.hs-boot view

file too large to diff

+ GI/Gtk/Types.hs view

file too large to diff

− GI/GtkAttributes.hs

file too large to diff

− GI/GtkSignals.hs

file too large to diff

gi-gtk.cabal view

file too large to diff